perm filename CORE[KA,SYS] blob
sn#223195 filedate 1976-07-06 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00031 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00004 00002 SUBTTL CORE ROUTINES FOR SWAPPING SYSTEM. 4 AUG 67 ↔ BEGIN CORE
C00011 00003 CORINI INITIALIZE CORE TABLES
C00017 00004 CORE UUO CORUUO, UCORE, RUNCOR
C00023 00005 CHKSHF - THE CORE SHUFFLER CHKSHF, SPWCNT
C00032 00006 SUBTTL ANYACT ROUTINE TO TEST FOR ANY ACTIVE DEVICES
C00039 00007 SUBTTL CORE0
C00043 00008 CORE1, SHFCOR
C00050 00009 CORGET, BAKOLD, CORG1
C00057 00010 DIDDLE DIDLE, DIDLEA, DIDLE2
C00064 00011 HOLSRC
C00067 00012 CORCHK AND CORTCK -- CHECK CORTAL AGAINST CORTAB AND CHECK CORTAB AGAINST WORLD
C00072 00013 CORSTG - SET AND CLEAR CORE USE TABLE CORGBP,CORSGT
C00077 00014 GETPR GET A JOB'S PROTECTION-RELOCATION
C00081 00015 SUBTTL RELOCA
C00089 00016 LOCK AND UNLOCK UUOS.
C00099 00017 LTHMOV, HTLMOV
C00108 00018 SUBTTL FREE STORAGE AND OTHER POLITICAL PRISONERS
C00109 00019 INITIALIZE FREE STORAGE - FSINIT
C00116 00020 COMMENT $ FSGET: GET FREE STORAGE AT ANY LEVEL.
C00133 00021 SWIPE 1K FROM AVAILABLE USER SPACE.
C00138 00022 FSCLK: CLOCK LEVEL (CHANNEL 7) ROUTINES TO KEEP FREE STORAGE HAPPY!
C00144 00023 FSQUIK, FSGIVE - RETURN FREE STORAGE TO SYSTEM.
C00156 00024 GET FREE STORAGE AT UUO LEVEL.
C00157 00025 RELPDL - RELEASE THE JBTPDL
C00159 00026 SPARE LIST HANDLER FOR DPYSER & TTYSER -- SFSINI SFSCLK
C00162 00027 VERSION OF FSGET TO USE SPARE LIST -- SFSGET
C00165 00028 ARRRGH! PI LEVEL AND NO FAILURE POSSIBLE! HERE WE CURL UP AND DIE
C00166 00029 VERSION OF FSGIVE TO THINK ABOUT PUTTING RETURNED BLOCK INTO SPARE LIST -- SFSGIV SFSREL
C00168 00030 YES FANS, IT'S THE INFAMOUS RELEX, FORMERLY SCATTERED THROUGH TTYSER & DPYSER
C00171 00031 GETMAP,GIVMAP MANIPULATE 512-WORD PAGES OF FREE STORAGE.
C00174 ENDMK
C⊗;
SUBTTL CORE ROUTINES FOR SWAPPING SYSTEM. 4 AUG 67 ↔ BEGIN CORE
COMMENT $
Core is allocated on a 512-word page basis. A table of 9-bit bytes
CORTAB is kept in which each byte corresponds to a page of addressable
memory. [In the FTPAGER version, these bytes are sliced out of the CST.]
Each byte is marked with one of the following codes:
0 Block is available.
1-77 Block is in use by the job named in this code
101 Block is occupied bt the system
103 Block does not exist (NXM)
105 Block is in use by system as free storage.
110 Block is in use as a page table (not as free storage)
When the system is initialized, CORINI sets the CORTAB table to
reflect blocks in use by the system and non-existant blocks.
RMEMSIZ minimum of total memory size and 1000000
37 (system JOBREL for Exec DDT) is one less than RMEMSIZ
MEMSIZ address of the bottom of free storage
CORMAX number of words of low core free (MEMSIZ-SYSTOP)
CORTAL numbr of pages of low core free
LOKTOP bottom address of unlocked core (initially same as SYSTOP)
SYSTOP bottom address of user space.
TMEMSIZ total memory size in entire system (may exceed 1000000)
FSINIT completes the task of initializing core. FSINIT is called for
every 200 restart, initialization, or reload. FSINIT unlocks any
locked core, returns any claimed free storage to the general core
pool and then initializes free storage to contain one block of size
FSNINIT*1024 words.
The area between LOKTOP and MEMSIZ (LOKPAG-MEMPAG) is available
for allocation to users. Also the area between FHUPAG and LHUPAG
may be allocated as high core. Locked core affects LOKTOP/LOKPAG.
Free storage affects MEMSIZ/MEMPAG.
Core routines affect the following globals (and others!):
JBTPAG, CORTAL, CORTAB, HOLEF, SHFWAT, JBTMAP.
Core Allocation Routines:
Generally TAC must be setup to the desired core size for the job
whose number is in J.
CORUUO is called by the CORE UUO, CORE2 and REMAP UUOs. For lowers,
there is already core in core. For uppers, there may not be any
physical core assigned. CORUUO calls UCORE. CORUUO stores the
number of free blocks available by calling STOTAC.
UCORE is called by CORUUO and by BUFCLC, always at UUO level. UCORE
calls IOWAIT to wait for IO to stop, then calls either CORE1 or CORE0
(CORE0 if there's no core assigned to this job), upon return WSCHED
is called, because resulting core may be assigned on swapping disk.
RUNCOR is called at UUO level (monitor job) for SAVGET. Core already
is assigned to the job. Calls CORE1 then WSCHED. Unlike CORUUO,
RUNCOR does not store the number of free blocks into user's core.
CORE0 is called at clock level. If job already has core in core, it calls
CORE1. CORE0 is used by ZEROSEG, FINOUT (to release core), by KILCM7
and RUNCOM (to assign a job data area) and by the console CORE
command to change a job's core assignment without running that job.
If a job has no core in core (either swapped out, or NULQ) then CORE0
will assign core on the disk.
CORE1 is called at any level. Job must already have some core. The
new core assignment may be zero.
CORGET is called if a job has no core (or when it's core has been
temporarily marked free prior to assigning new core). Called by
CORE1 and INJOB.
CORGET assigns core to a job, if possible, sets the use code in
CORTAB, and moves the job if this assignment is at a different place
than the old core. If CORGET can't assign new core, it restores the
old assignment, if any, and calls XPAND to cause the job to be
swapped out. Then the swap-in process will assign new core.
The table, JBTPAG, is updated by the core routines. For each job in
core, JBTPAG is the number of pages,,first page. JBTADR is computed
from JBTPAG. JBTADR contains the protection (size) and relocation
for each job in core. Also, JOBREL in the user's core image is
modified by the core routines. If the current job is changing its
core allocation, the APR map is changed accordingly. JBTMAP entries
for each job are maintained to correspond to JBTPAG.
$
;Special AC names (also TAC, TAC1, PROG, IOS, DDB, and P are used)
BLK←AC1 ;HIGHEST REL. ADR. IN USER AREA
LOC←DSER ;ABS. LOC. OF FIRST BLOCK IN USER AREA
;CORINI INITIALIZE CORE TABLES
;REG THIS PAGE. 1972: 22 FEB, 15 APRIL, 28 APRIL.
;HISYS REVISIONS. REG 12/75 1/76
↑CORINI:MOVE TAC,[XWD CORBEG,CORBEG+1]
SETZM CORBEG
BLT TAC,COREND
NOKL10,< CONO APR,NXM ;CLEAR NXM>
IFKL10,< CONO APR,KLCLRF!7740 ;CLEAR NXM, ETC.
PUSH P,KLUPT+KLPFNP ;SAVE STANDARD PAGE FAULT TRAP
MOVEI TAC,CORIPF ;OUR TRAP HANDLER
MOVEM TAC,KLUPT+KLPFNP ;NEW PC FOR PAGE FAIL
>;IFKL10
;FOR FTEXPG, MAP IS ALREADY SUPPOSED TO BE TURNED ON!
;TRAPS (WHICH SHOULDN'T HAPPEN) WILL GO TO INITRP IN SYSINI
IFN FTEXPG,< MOVSI TAC,160040 ;PAGE TABLE POINTER TO 0
MOVEM TAC,EXPGT+PAREXP ;CLOBBER MAP >;IFN FTEXPG
MOVSI AC3,-PHYMEM*2 ;NUMBER OF PAGES OF PHYSICAL CORE TO SCAN.
CORI1: MOVEI TAC1,(AC3) ;GET PAGE NUMBER
LSH TAC1,=9 ;SHIFT TO MAKE PHYSICAL ADDRESS
IFN FTEXPG,< HRRM AC3,EXPGT+PAREXP ;STORE PAGE NUMBER TO REFERENCE
NOKL10,< CONO PAG,1 ;CLEAR ARS MAPPING EXEC PAGES.>;NOKL10
IFKL10,< CONO KLPAG,@KLPCON >;IFKL10
HLLZ DAT,20!PAREXP⊗=9 ;REFERENCE MEMORY >;IFN FTEXPG
IFE FTEXPG,< HLLZ DAT,(TAC1) ;REFERENCE MEMORY >;IFE FTEXPG
IFN FTHSYS,< MOVEI TAC,(AC3)
CAIL TAC,1000
CAML TAC,FHUPAG ;SKIP IF THIS IS AN HISYS ADDR>;FTHSYS
CAMGE TAC1,SYSTOP ;SKIP IF ADDRESS IS BEYOND SYSTEM.
TROA DAT,2 ;SYSTEM PAGE. CODE WILL BE 103
NOKL10,< CONSZ APR,NXM ;SKIP UNLESS NXM >
IFKL10,< CONSZ APR,KLNXM ;SKIP UNLESS NXM >
TRC DAT,103 ;NXM CODE IS 103, IF SYSTEM, SET TO 101
MOVEI LOC,(AC3)
PUSHJ P,CORGBP ;COMPUTE BYTE POINTER TO CORTAB
DPB DAT,TAC ;MARK CORTAB FOR THIS PAGE.
TRNE DAT,2 ;SKIP IF NO NXM
JRST CORI2 ;NXM. QUIT NOW.
AOBJN AC3,CORI1 ;LOOP IF STILL WITHIN CONFIGURATION LIMIT
HRRZ AC3,AC3 ;END OF CONFIGURATION AC3←FIRST NXM PAGE
MOVEI LOC,(AC3)
PUSHJ P,CORGBP
MOVEI DAT,103 ;CODE FOR NXM
DPB DAT,TAC ;STORE NXM BYTE AT END OF CORTAB.
CORI2: MOVEI TAC1,(AC3)
CAILE TAC1,1000
MOVEI TAC1,1000 ;RMEMSIZ MAXIMUM IS 1,,0
LSH TAC1,=9
MOVEM TAC1,RMEMSIZE ;ADDRESS OF FIRST NXM.
MOVEM TAC1,MEMSIZ ;SETUP LOWEST ADDRESS IN FREE STORAGE
MOVE TAC,TAC1
LSH TAC,-=9
MOVEM TAC,MEMPAG
MOVE TAC,TAC1 ;COPY RMEMSIZE
SUB TAC,SYSTOP ;MINUS (LOW) SYSTEM SIZE
MOVEM TAC,CORMAX ;IS MAXIMUM SIZE OF (LOW) USER CORE.
LSH TAC,-=9
MOVEM TAC,CORTAL ;NUMBER OF PAGES IN (LOW) USER CORE.
SUBI TAC1,1 ;DECREMENT TO MAKE SYSTEM JOBREL
MOVEM TAC1,37 ;SAVE SYSTEM JOBREL FOR EXEC DDT AND UEDDT
IFN FTEXPG,< ANDI AC3,-1 ;IGNORE LEFT HALF = -PAGES THAT AREN'T THERE
MOVEI TAC,(AC3)
CAIL TAC,GOODPG ;DID WE SEE ONLY "GOOD" PAGES?
MOVEI TAC,GOODPG ;NO. RESTRICT CORHTL TO GOOD PAGES ONLY
MOVEM TAC,LHUPAG ;ONE PAST LAST HIGH USER PAGE.
SUB TAC,FHUPAG
MOVEM TAC,CORHTL ;NUMBER OF FREE PAGES IN HIGH CORE
LSH AC3,=9
MOVEM AC3,TMEMSIZ ;SAVE TOTAL MEM FOR PARSER, ETC.
SETZM EXPGT+PAREXP ;FLUSH RANDOMNESS FROM EXPGT
NOKL10,< CONO PAG,1 ;AND FROM THE PAGER >;NOKL10
IFKL10,< CONO KLPAG,@KLPCON >;IFKL10
>;FTEXPG
MOVEI TAC,%SWPL
; SKIPN FBACT
; MOVEI TAC,400000 ;3330 SWAPPER ONLY WORKS THIS BIG.
; CAILE TAC,%SWPL
; MOVEI TAC,%SWPL
MOVEM TAC,SWAPLI ;SET SYSTEM SWAPLIMIT.
NOKL10,< CONO APR,NXM ;CLEAR NXM>
IFKL10,< CONO APR,KLCLRF!7740 ;CLEAR NXM, ETC.
POP P,KLUPT+KLPFNP >;IFKL10
POPJ P,
IFKL10,<
CORIPF: CONSO APR,KLNXM ;SEEN A NXM?
HALT . ;NO. NO REASON TO FAULT.
CONO APR,KLCLRF!7740-KLNXM ;CLEAR PARITY ERRORS, KEEP NXM
AOS KLUPT+KLPFPC ;ADVANCE OVER FAILING INSTR.
MOVEI DAT,0
JRST 2,@KLUPT+KLPFPC
>;IFKL10
SUBTTL CORE UUO ;CORUUO, UCORE, RUNCOR
COMMENT $
CALL: MOVEI AC,<HIGHEST RELATIVE ADDRESS DESIRED>
CALL AC,['CORE '] OR CALLI AC,11
<ERROR RETURN: CAN'T ASSIGN CORE>
OK RETURN. JOB MAY HAVE BEEN SHUFFLED OR SWAPPED.
The number of 1K blocks that a job may have is returned in the AC.
If called with AC containing zero, then the core allocation is not
changed and the error return is taken with AC returing the number of
free blocks.
CORUUO is called for the CORE UUO, and by REMAP and CORE2 UUOs.
For the CORE2 UUO, J will be setup to the job number of the upper
that's being affected. Only in the case of the CORE2 UUO is there
the possibility that the job involved has no core assigned prior to
the UUO.
UCORE is called by CORUUO and by BUFCLC (always at UUO level).
RUNCOR is called at UUO level (monitor job) for SAVGET.
$
↑CORUUO:JUMPE TAC,ZERCOR ;IS ARGUMENT ZERO?
AOS (P) ;ASSUME SUCCESS RETURN.
PUSHJ P,UCORE ;DO IT. (CORE1 WILL FORCE UNLOCK)
SOS (P) ;BAD ASSUMPTION. FAILURE RETURN.
ZERCOR: MOVE TAC,CORMAX ;GET CURRENT FREE SPACE.
CAMLE TAC,SWAPLIMIT ;MORE THERE THAN HE CAN HAVE?
MOVE TAC,SWAPLIMIT ;YES. TELL HIM MAX WE'LL ALLOW.
ASH TAC,-=10 ;IN 1 K BLOCKS (KEEP IT THE OLD WAY)
JRST STOTAC ;RETURN CORMAX TO USER
;(HERE FROM BUFCLC WITH TAC←DESIRED JOBREL, TO EXPAND CORE FOR IO BUFFERS)
↑UCORE: IORI TAC,1777 ;ROUND UP TO A 1K BOUNDARY.
MOVE TAC1,JBTSTS(J) ;GET JOB STATUS
TLNN TAC1,JSEG ;AND SKIP IF THIS IS AN UPPER.
JRST CORCS2 ;NOT AN UPPER.
PUSH P,J ;SAVE UPPER'S JOB NUMBER.
MOVEI J,JOBN-1 ;LOOK THRU ALL JOBS...
CORCSO: LDB TAC1,PSEGN ;DOES THIS GUY POINT TO ME?
CAME TAC1,(P) ;SKIP IF A USER OF THIS UPPER.
JRST CORCSL ;NO.
MOVE TAC1,J ;TAC1 ← JOB NUMBER OF THIS LOWER.
PUSHJ P,CORSGT ;GET THE SIZE OF THIS LOWER INTO TAC1
ADDI TAC1,1(TAC) ;LOWER SIZE + MY REQUEST SIZE.
CORCS3: CAMG TAC1,SWAPLIMIT ;SKIP IF TOO BIG TO SWAP
CAMLE TAC1,CORMAX ;SKIP UNLESS TOO BIG TO FIT IN CORE
JRST .+2 ;TOO BIG
JRST CORCSL ;NOT TOO BIG. CHECK OTHER LOWERS.
POP P,J ;THIS LOWER AND ME WONT FIT
POPJ P, ;GIVE THE ERROR RETURN.
CORCSL: SOJG J,CORCSO ;CONTINUE SCAN THRU ALL JOBS.
POP P,J ;RESTORE J
JRST CORXOK ;SO FAR, SO GOOD.
CORCS2: LDB TAC1,PSEGN ;NOT A SEGMENT. HAS IT AN UPPER?
SKIPE DAT,TAC1 ;SKIP IF NO UPPER. GET NUMBER IN DAT
PUSHJ P,CORSGT ;GET SIZE OF UPPER IN TAC1.
ADDI TAC1,1(TAC) ;UPPER'S SIZE + THIS REQUEST.
CAMG TAC1,SWAPLIMIT ;IS COMBINATION TOO BIG?
CAMLE TAC1,CORMAX ;DOES IT FIT?
POPJ P, ;NOPE.
CORXOK: PUSH P,TAC ;SAVE SIZE WE WANT TO BE.
PUSH P,UUO ;SAVE
PUSH P,J ;SAVE J IF THIS IS A SEGMENT.
PUSHJ P,IOWAIT ;WAIT FOR ALL IO TO STOP.
JRST .+2
CORYOK: PUSHJ P,WSCHED
PUSHJ P,ANYACT ;MAKE SURE WE CAN BE MOVED.
JRST CORYOK ;NO. WAIT UNTIL WE CAN.
POP P,J ;RESTORE J
POP P,UUO
POP P,TAC ;HIGHEST REL. LOC. DESIRED
MOVEI TAC1,CORE0 ;CALL CORE0 IF THERE'S NO CORE ALREADY
SKIPE JBTPAG(J) ;SKIP IF THERE IS NO OLD CORE ASSIGNMENT
↑RUNCOR:MOVEI TAC1,CORE1 ;CALL CORE1 IF THERE'S CORE ALREADY.
AOS (P) ;SET SKIP RETURN.
PUSHJ P,(TAC1) ;REASSIGN CORE, OR GET NEW CORE ON DISK
SOS (P) ;FAILURE RETURN.
PUSHJ P,WSCHED ;IN CASE CORE IS NOW ON DISK, STOP JOB
MOVE TAC1,JBTSTS(J)
TLNE TAC1,JSEG ;SKIP IF THIS IS A LOWER.
PUSHJ P,UAPPLY ;CONTINUE SPACWAR FOR ALL LOWERS
PUSHJ P,SPWCNT ;(ARG TO UAPPLY) CONTINUE SPACEWAR FOR LOWER
POPJ P,
SUBTTL CHKSHF - THE CORE SHUFFLER ;CHKSHF, SPWCNT
COMMENT $
The Swapper calls CHKSHF because core is fragmented. The
fragmentation of core is indicated by CORTAL being sufficient to fit
a job, but CORGET failing to allocate core. When CHKSHF is called,
the job above the lowest hole in core (the hole is indicated by
HOLEF) is located and if it has no IO (or spacewar) active, it is
shuffled into the bottom of that hole. In this way core becomes
compacted until a hole sufficiently large for the Swapper's purpose
is created. If the job to be shuffled has IO active, then SHFWAT is
set to that job's number, the SHF bit is set in his JBTSTS, and
CHKSHF goes away (also spacwar suspension is requested). Eventually
that job should become shuffleable, and it will be moved. If SHFWAT
is set, the swapper will call CHKSHF every tick until the job gets
moved.
Note that devices look at the SHF bit in JBTSTS (at ADVBFF and
ADVBFE) to see if the monitor is waiting to shuffle this job. Also,
the scheduler will not run a job that has SHF set, thus preventing
further IO from being initiated.
The state of the map is supposed to be saved before CHKSHF is called.
$
↑CHKSHF:HGMAC (26)
SKIPE J,SHFWAT ;DID WE STOP A JOB TO WAIT FOR IO INACTIVE?
JRST SHFLOP ;YES, SEE IF IO HAS STOPPED YET
SKIPN TAC,HOLEF ;NO, DOES CORE HAVE A HOLE IN IT?
JRST DIDLE4 ;NO? RECALCUATE SWAPPER'S PARAMETERS.
CHKSHZ: CAML TAC,MEMPAG ;SKIP IF HOLEF IS WITHING REASON.
JRST CHKERR
PUSHJ P,CORGB1 ;MAKE A BYTE POINTER FROM HOLEF
LDB J,TAC ;GET A USE BYTE
CAIGE J,JOBN ;VALIDITY CHECK-SKIP IF ILLEGAL
JUMPG J,SHFLOA ;FOUND ONE?
SHFLOB: PUSHACS
PUSHJ P,DISDATE
PUSHJ P,DISMES
ASCIZ /HOLEF = /
MOVE TAC,HOLEF
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ / BUT NO HOLE PRESENT. CORTAB = /
MOVE TAC,HOLEF
PUSHJ P,CORGB1 ;GET A BYTE POINTER.
LDB J,TAC ;GET THE BYTE.
PUSHJ P,DISJOB ;PRINT JOB NAME & NUMBER.
PUSHJ P,DISCRLF
PUSHJ P,DISFLU
PUSHJ P,DDTCAL
POPACS
JRST DIDLE4 ;RECALCULATE SWAPPER'S PARAMETERS
CHKERR: PUSHACS
PUSHJ P,DISMES
ASCIZ /HOLEF OUT OF BOUNDS = /
MOVE TAC,HOLEF
PUSHJ P,DISOCT
PUSHJ P,DISCRLF
POPACS
JRST DIDLE4 ;RECALCULATE HOLEF
SHFLOA: HRRZ TAC,JBTPAG(J)
CAME TAC,HOLEF
JRST SHFLOB ;LOSER!
SHFLOP: SKIPN JBTPAG(J) ;SKIP IF THIS JOB IS STILL INCORE.
JRST NOTSH1 ;NO CORE. HE CAN'T BE SHUFFLED, SO CLEAR SHFWAT
PUSHJ P,SHFCOR ;IN A LOWER POSITION IN CORE
JRST NOTSHF ;CANNOT ONLY IF IO IS ACTIVE
NOTSH1: SETZM SHFWAT ;JOB HAS BEEN SHUFFLED, CLEAR FLAG
MOVSI TAC,SHF ;CLEAR SHUFFLE WAIT BIT IN CASE IT WAS ON
ANDCAB TAC,JBTSTS(J)
SKIPN JBTPAG(J) ;IF WE DON'T HAVE CORE, DON'T CONTINUE SPACEWAR
JRST DIDLE4 ;GO RECALCULATE SWAPPER'S PARAMETERS
TLNE TAC,JSEG ;SKIP UNLESS THIS IS AN UPPER.
PUSHJ P,UAPPLY ;FOR UPPERS, CONTINUE SPACEWAR FOR ALL LOWERS.
PUSHJ P,SPWCNT ;(ARG TO UAPPLY). FOR LOWER, CONTINUE SPACEWAR
JRST DIDLE4 ;RECALCULATE SWAPPER'S PARAMETERS
NOTSHF: SKIPN HOLEF ;JOB CAN'T BE MOVED. STILL ACTIVE IO.
JRST NOTSH1 ;HOLE ISN'T THERE ANYMORE?
MOVM TAC,FORCE
CAME J,FIT
CAMN J,TAC
JRST NOTSH1 ;IF THIS JOB IS BEING SWAPPED, DON'T SHUFFLE
MOVEM J,SHFWAT ;SET SHUFFLE WAIT FLAG WITH JOB NO.
SKIPE SP2GO(J) ;DOES THIS JOB HAVE SPACEWAR ACTIVE?
SKIPN SP2GO(J)
JRST NOTSH5 ;NO SPACEWAR ACTIVE
HLRZ TAC,JBTST2(J)
ANDI TAC,SPWST1!SPWST2
CAIE TAC,SPWST1!SPWST2 ;SKIP IF SPW IS SUSPENDED.
POPJ P, ;UNTIL SPW IS SUSPENDED, ALLOW USER TO RUN
NOTSH5: MOVSI TAC,SHF ;SET SHF WAIT BIT IN JOB STATUS WORD
IORM TAC,JBTSTS(J) ;TO KEEP THE JOB FROM BEING RUN
POPJ P, ;AND IO WILL STOP SOON (WE HOPE)
↑SPWCNT: ;CONTINUE A SPW JOB
SKIPN JBTST2(J) ;IS THERE A SPW JOB HERE??
POPJ P, ;NO.
PSYNC SPWCSC
MOVSI TAC,SPWST1!SPWST2 ;CLEAR SUSPENSION STATUS
ANDCAM TAC,JBTST2(J)
XSYNC SPWCSC
POPJ P,
SUBTTL ANYACT ROUTINE TO TEST FOR ANY ACTIVE DEVICES
COMMENT $
CALLING
MOVE J,JOB NUMBER
PUSHJ P,ANYACT
<HERE IF DEVICES ACTIVE>
<HERE IF NO DEVICE IS ACTIVE, EXCEPT POSSIBLY TTY>
$
↑ANYACT:
MOVE UCHN,JBTSTS(J) ;GET JOB STATUS
TLNN UCHN,JSEG ;SKIP IF THIS IS AN UPPER
JRST ANYAC3 ;THIS IS A LOWER
PUSH P,PROG ;SAVE VITAL DATA.
PUSH P,J ;SAVE THIS JOB NUMBER.
AOS -2(P) ;ASSUME SUCCESS RETURN.
MOVEI J,JOBN-1 ;SEARCH THRU ALL JOBS.
ANYAC1: LDB UCHN,PSEGN ;LOOKING FOR LOWERS THAT POINT HERE
CAME UCHN,(P) ;DOES THIS POINT TO ME.
ANYA1A: SOJG J,ANYAC1 ;NO. DECREMENT J AND LOOP
JUMPLE J,ANYAC2 ;JUMP IF WE HAVE EXHAUSTED THE LOOP
PUSHJ P,ANYAC3 ;CALL ROUTINE FOR A LOWER SEGMENT
SOSA -2(P) ;CAN'T MOVE THIS LOWER. SET NO-SKIP
JRST ANYA1A ;THIS LOWER DOESN'T CARE IF WE MOVE
ANYAC2: POP P,J
POP P,PROG
POPJ P,
;HERE FOR A LOWER SEGMENT ONLY.
ANYAC3: SKIPN JBTPAG(J) ;ANY CORE THERE?
JRST CPOPJ1 ;NO CORE MEANS NO IO ACTIVE.
SKIPN SP2GO(J) ;IS A P2 SPACEWAR JOB RUNNING?
SKIPE SPWGO(J) ;OR IS A P1 SPACEWAR JOB RUNNING?
CAIA ;SPACEWAR ACTIVE.
JRST ANYAC4 ;NO SPACEWAR WORRIES.
PSYNC SPWCSC
MOVE IOS,JBTST2(J)
TLC IOS,SPWST1!SPWST2
TLCN IOS,SPWST1!SPWST2
JRST ANYA3A ;SPW IS SUSPENDED.
MOVSI IOS,SPWSUS ;NO. MARK IT FOR SUSPENSION
TDNN IOS,JBTST2(J) ;SKIP IF SUSPENSION REQUEST SET ALREADY.
IORM IOS,JBTST2(J) ;SET THE BIT THAT REQUESTS SPW SUSPENSION
XSYNC SPWCSC
POPJ P, ;CAN'T MOVE JOB UNTIL SPACEWAR IS SUSPENDED
ANYA3A: XSYNC SPWCSC
ANYAC4: SKIPN JBTIIP(J) ;INTERRUPT IN PROGRESS?
SKIPE JBTGLU(J) ;NO. IS SOMEONE GLUEING HIM?
POPJ P, ;(JBTGLU OR INTIIP) FAKE ACTIVE DEVICE.
AOS (P) ;ASSUME SUCCESS (IT DOES HAPPEN SOMETIMES)
PUSH P,TAC ;IMPORTANT THAT WE SAVE TAC!
PUSHJ P,ANYAC5
SOS -1(P)
JRST TPOPJ ;RESTORE TAC AND SKIP OR NOT
ANYAC5: PUSHJ P,MAPSET
CAMN J,JOB(PID) ;IS THIS THE CURRENT JOB
PUSHJ P,S2U ;YES. COPY USRDAT TO JOBDAT.
MOVEI IOS,IOACT ;IO DEVICE ACTIVE BIT
XCTR XR,[SKIPGE AC2,JOBHCU] ;AC2←NUMBER OF USER IO CHANNELS IN USE
MOVNI AC2,JOBJDA-JOBHCU ;C(JOBHCU) POINTS TO SAVGET DDB
CAILE AC2,17 ;IS HIGHEST CHANNEL LEGAL?
JRST ANYHCC ;JOBHCU IS CLOBBERED.
MOVSI TAC1,DVTTY ;DEVICE IS A TTY BIT
ANY: XCTR XR,[HRRZ DDB,JOBJDA(AC2)] ;IS A DEVICE ASSIGNED TO THIS CHANNEL?
JUMPE DDB,ANY2 ;NO.
CAIL DDB,CHKBEG ;CHECK ADDRESS. SKIP IF LOW CORE
CAML DDB,MEMSIZ ;SKIP IF BELOW F.S. (NO NO)
CAML DDB,RMEMSIZ ;BELOW REAL MEM? (REDUNDANT FOR LOW CORE)
JRST ANY7 ;LOSING ADDRESS
TDNE IOS,DEVIOS(DDB) ;YES, IS IT ACTIVE?
TDNE TAC1,DEVMOD(DDB) ;YES. SKIP IF IS NOT A TTY.
JRST ANY2
POPJ P,
ANY2: SOJGE AC2,ANY ;THIS CHANNEL IS OK.
SKIPA UCHN,JBTIOP(J) ;GET THE JBTPDL (IF ANY) AND SKIP.
ANY2A: ADD UCHN,[2,,2] ;ADVANCE TO NEXT DDB
JUMPGE UCHN,CPOPJ1 ;JUMP IF IOPDL EXHAUSTED.
SKIPN DDB,(UCHN) ;GET DDB POINTER
JRST ANY2A ;IGNORE ONES THAT AREN'T THERE
TDNE IOS,DEVIOS(DDB) ;IOACT ON?
TDNE TAC1,DEVMOD(DDB) ;YES, TTY?
JRST ANY2A ;TTY OR NOT IOACT.
POPJ P, ;ACTIVE IO
ANY7: PUSHACS ;DDB ADDRESS IS OUT OF BOUNDS.
XCTR XW,[SETZM JOBJDA(AC2)] ;BLAST ILLEGAL DDB POINTER
SKIPGE AC2
XCTR XW,[SETZM JOBJDA] ;IN CASE IT WAS SAVGET, ZERO CHANNEL 0
PUSHJ P,DISDATE
PUSHJ P,DISJOB
PUSHJ P,DISMES
ASCIZ / ANY7: ILLEGAL DDB ADDRESS = /
HRRZ TAC,DDB-17(P) ;PICK UP ADDRESS
PUSHJ P,DISLOC ;TYPE ADDRESS IN OCTAL
PUSHJ P,DISMES
ASCIZ /; USER IO CHANNEL /
SKIPGE TAC,AC2-17(P)
JRST ANY7A
PUSHJ P,DISLOC
PUSHJ P,DISCRLF
JRST ANY7B
ANY7A: PUSHJ P,DISMES
ASCIZ / SAVGET
/
ANY7B: POPACS
JRST ANY2
ANYHCC: PUSHACS
PUSHJ P,DISDAT
PUSHJ P,DISJOB
PUSHJ P,DISMES
ASCIZ / JOBHCU CLOBBERED AT ANYACT. JOBHCU = /
MOVE TAC,AC2-17(P)
PUSHJ P,DISOCT
PUSHJ P,DISCRLF
POPACS
XCTR XW,[SETZM JOBHCU] ;SET ONLY USER CHANNEL 0 IN USE.
XCTR XW,[SETZM JOBJDA] ;CLEAR USER CHANNEL 0.
JRST CPOPJ1 ;FAKE SUCCESS RETURN.
SUBTTL CORE0
COMMENT $
CORE0 is called by the CORE command or for the initial core
assignment of just a job data area for the RUN command, etc. Devices
may be active, or the job may have no previous core. When CORE0 is
called for a job that either has no core or is swapped out, the new
"core" assigned will be swapped out. If IMGOUT is zero (i.e., we are
assigning new core where there was none before) then the swapper will
clear the job data area (CLRJB1) and clear JOBSA.
CALL: MOVE TAC,HIGHEST LEGAL ADDRESSABLE LOC. DESIRED
MOVE J,JOB NUMBER
PUSHJ P,CORE0
<ERROR> ;EITHER JOB HAS ACTIVE IO, OR NOT ENOUGH CORE
<OK>
The job may be moved if necessary to satisfy this request. The new
core assignment is set in PROG on either return (zero means none
assigned). The success return will be given even if the "core"
assigned is swapped out. CORE0 does not wait for the core to be
swapped in.
$
↑CORE0: CAML TAC,SWAPLIMIT ;IS HE BEING TOO GREEDY.
POPJ P, ;FLUSH THE GREEDY BASTARD
SKIPE JBTPAG(J) ;SKIP IF THERE IS NO CORE ASSIGNED IN CORE
JRST CORE0A ;JOB HAS CORE IN CORE.
MOVSI TAC1,SWP ;IS THERE CORE ON THE DISK?
TDNN TAC1,JBTSTS(J)
DPB TAC1,IMGOUT ;NO CORE ON THE DISK. ZERO IMGOUT.
IORM TAC1,JBTSTS(J) ;MARK CORE AS SWAPPED OUT (IF ZERO CORE)
JUMPE TAC,CORE0B ;JUMP IF REQUESTING NO CORE.
IORI TAC,777
ADDI TAC,1
LSH TAC,-=9 ;CONVERT CORE REQUEST TO PAGE COUNT
JRST CORE0K
;ENTER AT CORE0K TO ADJUST CORE IMAGE SIZE WHILE JOB IS ON DISK.
;(THIS IS CALLED FROM THE COMMAND DECODER TO SHRINK BEFORE COMAND)
CORE0B: ANDCAM TAC1,JBTSTS(J) ;REQUESTING NO CORE. CLEAR "CORE ON DISK" BIT.
↑CORE0K:
PRINTX HERE'S AN EVEN-PAGE CROCK!
TRNE TAC,1
ADDI TAC,1
DPB TAC,IMGIN ;STORE NEW CORE IMAGE BLOCK SIZE (IN PAGES)
IFN FTSTAT,< PUSH P,TAC
LSH TAC,6
TRO TAC,CSZSTA
PUSHJ P,STAPUT
POP P,TAC >;FTSTAT
SETZM SWPCNT ;WAKE UP SWAPPER NEXT TICK
LDB TAC1,IMGOUT ;SIZE ON DISC (PAGES)
CAMGE TAC,TAC1 ;IS NEW SIZE LESS THAN AMOUNT ON DISC?
DPB TAC,IMGOUT ;YES, REPLACE DISC SIZE
JRST CPOPJ1 ;GIVE SKIP RETURN
;CORE1, SHFCOR
COMMENT $
CORE1 is called from UCORE (CORE, CORE2, REMAP UUOs, and BUFCLC), and
from RUNCOR when the RUN command reassigns the proper amount of core
after reading the directory to see how big the file is. The job must
already have core assigned and no active devices. Old core is
returned to the system and CORGET is called to assign new core.
$
CORE0A: PUSHJ P,ANYACT ;(HERE FROM CORE0) ANY ACTIVE DEVICE?
POPJ P, ;YES, CANNOT ASSIGN CORE
↑CORE1: ANDI TAC,-1 ;LOOK AT RIGHT HALF ONLY.
CAMGE TAC,CORMAX ;IS THIS TOO MUCH?
CAML TAC,SWAPLIMIT ;CAN HE HAVE THIS MUCH?
POPJ P, ;NO
MOVE LOC,JBTSTS(J)
TRNE LOC,JLOCK
PUSHJ P,UNLOCK ;RELEASE LOCKED CORE
ADDI TAC,1 ;CONVERT REQUEST TO WORD COUNT
LSH TAC,-=9 ;CONVERT REQUEST TO PAGES
CORE1A: HRRZ LOC,JBTPAG(J) ;FIRST PAGE OF OLD ASSIGNMENT
HLRZ BLK,JBTPAG(J) ;NUMBER OF PAGES OF OLD ASSIGNMENT.
MOVE PROG,JBTPAG(J) ;PROG←OLD CORE ASSIGNMENT
JUMPE TAC,CORG2 ;JUMP IF DESIRED ASSIGNMENT IS ZERO.
CAIN TAC,(BLK) ;IF HE IS THE SAME
JRST DIDLEA ; LEAVE NOW
CAILE TAC,(BLK) ;IF HE IS EXPANDING
JRST CORG2 ; LET HIM EXPAND
IFN FTHPSG,< CAIL LOC,1000
JRST CORSHC ;SHRINK IN HIGH CORE >
ADDI LOC,(TAC) ;LOC←FIRST PAGE TO FREE
HLRZ BLK,JBTPAG(J)
SUBI BLK,(TAC) ;BLK←NUMBER OF PAGES TO GIVE BACK
IFN FTPAGER,< PUSHJ P,ZMAPL ;CLEAR OUT THESE PAGE MAP ENTRIES
SETZM (TAC1) >;FTPAGER
MOVEI UCHN,0
PUSHJ P,CORSTG
HRLI PROG,(TAC) ;PROG←NUMBER OF PAGES,,FIRST PAGE
JRST DIDLEA
SHFCOR: PUSHJ P,ANYACT ;ENTER HERE FROM THE SHUFFLER.
POPJ P,
PUSHJ P,APRMAP ;SETUP MAP FOR THIS USER. CALLER SHOULD SAVE MAP.
HRRZ LOC,JBTPAG(J)
HLRZ BLK,JBTPAG(J)
MOVE TAC,BLK ;DESIRED NEW CORE SIZE IS THE SAME AS WE HAD.
CORG2: MOVEI UCHN,0 ;MARK OLD CORE ASSIGNMENT AS FREE.
IFN FTHPSG,< CAIL LOC,1000 ;SKIP IF OLD CORE WAS LOW CORE
JRST CORGFH ;THINK ABOUT HIGH CORE.>
IFN FTPAGER,< PUSHJ P,LMAPL ;LOOP THROUGH PAGE MAP FOR LOWER'S PAGES
SETZM (TAC1) ; CLEARING THE ENTRIES >;FTPAGER
PUSHJ P,CORSTG ;RETURN OLD CORE TO FREE POOL
JRST CORG1 ;NOW, TRY TO ASSIGN NEW CORE.
IFN FTHPSG,< ;HERE IF OLD CORE WAS ASSIGNED IN HIGH CORE.
CORGFH: JUMPN TAC,CORXHC ;JUMP IF EXPANDING HIGH CORE.
PUSH P,LOC ;CORE 0 ON HIGH CORE SEGMENT
PUSH P,AC3
MOVE AC3,JBTMAP(J)
LSH AC3,=9
HRLI AC3,-1000
CORHF1: SKIPN TAC,(AC3) ;SKIP IF PAGE EXISTS.
JRST CORHF2
HRRZ TAC,TAC ;PAGE NUMBER OF THAT PAGE.
PUSHJ P,CORGB1
LDB UCHN,TAC
CAIE UCHN,(J)
HALT .+1
MOVEI UCHN,0
DPB UCHN,TAC ;ZERO THE CORTAB ENTRY
AOS CORHTL ;COUNT A PAGE FREE
SETZM (AC3) ;FLUSH JBTMAP ENTRY.
CORHF2: AOBJN AC3,CORHF1
POP P,AC3
POP P,LOC
PUSHJ P,HCBUG
MOVEI TAC,0
JRST CORG1
CORXHC: MOVEI AC3,(TAC) ;HERE TO EXPAND HIGH CORE
SUBI AC3,(BLK) ;AC3←NUMBER OF PAGES ADDITIONAL THAT ARE NEEDED.
CAMG AC3,CORHTL
JRST CORXH1 ;THERE'S ROOM ENOUGH IN HIGH CORE FOR THIS STUFF.
PUSH P,TAC ;SAVE DESIRED SIZE.
PUSHJ P,HTLMOV ;MOVE CORE FROM HIGH TO LOW
POP P,TAC
JRST CORE1A ;ONE MORE TIME.
CORXH1: PUSH P,TAC ;SAVE TOTAL COUNT TOO.
PUSH P,AC3 ;SAVE THE COUNT OF ADDITIONAL PAGES.
MOVE LOC,JBTMAP(J) ;ADDRESS OF JBTMAP
LSH LOC,=9
HLL LOC,(LOC) ;USE SAME LEFT HALF BITS IN NEW ENTRIES
ADDI LOC,(BLK) ;LOC←LH OF PAGE TABLE,,ADDRESS OF FIRST EMPTY ENTRY
MOVE BLK,FHUPAG
CORXH2: CAML BLK,LHUPAG
HALT . ;ERROR.
MOVEI TAC,(BLK)
PUSHJ P,CORGB1
LDB TAC1,TAC
JUMPN TAC1,CORXH3 ;JUMP IF THIS BLOCK IS IN USE.
DPB J,TAC
SOS CORHTL
MOVEM BLK,(LOC)
HLLM LOC,(LOC)
ADDI LOC,1
SOSLE (P)
CORXH3: AOJA BLK,CORXH2
SUB P,[1,,1]
POP P,TAC
MOVSI PROG,(TAC)
HRR PROG,JBTPAG(J)
PUSHJ P,HCBUG
JRST DIDLE
CORSHC: MOVE AC3,JBTMAP(J) ;HERE TO SHRINK IN HIGH CORE.
LSH AC3,=9
HRLI AC3,-1000(TAC)
ADDI AC3,(TAC) ;AOBJN POINTER TO JBTMAP ENTRIES TO THROW OUT
HRLI PROG,(TAC)
CORSC1: SKIPN TAC,(AC3) ;IS THERE CORE HERE?
JRST CORSC2 ;NO.
HRRZ TAC,TAC
PUSHJ P,CORGB1
LDB TAC1,TAC
CAIE TAC1,(J)
HALT .+1
SETZB TAC1,(AC3)
DPB TAC1,TAC
AOS CORHTL
CORSC2: AOBJN AC3,CORSC1
PUSHJ P,HCBUG
JRST DIDLE
>;FTHPSG
;CORGET, BAKOLD, CORG1
COMMENT $
CORGET assigns core. Called when a job has no core assigned (from
the swapper, or after CORE1 gave the old core away). If new core is
assigned, it will be in the lowest position possible. If the new
request cannot be granted, the old assignment is restored and the job
is marked for swapout by calling XPAND (see BAKOLD).
$
↑CORGET:CAMGE TAC,CORMAX ;IS THIS TOO MUCH?
CAML TAC,SWAPLIMIT ;CAN HE HAVE THIS MUCH?
POPJ P,
ADDI TAC,1
LSH TAC,-=9 ;CONVERT REQUEST TO PAGE COUNT.
CORG1: SETZB LOC,PROG ;SET NEW ASSIGNMENT AND DISTANCE MOVED TO 0
AOS NCORCALLS
JUMPE TAC,DIDLE2 ;EXIT IF ZERO IS CORE BEING REQUESTED
CAME J,SHFWAT ;WAITING FOR CURRENT JOB?
SKIPN SHFWAT ;IF SHUFFLING, PRETEND NOT AVAIL.
PUSHJ P,HOLSRC ;NO, SEARCH FOR HOLE BIG ENOUGH
SKIPA UCHN,JBTSTS(J) ;NO HOLE AVAILABLE. REASSIGN THE OLD CORE. SKIP.
JRST CORGT1 ;NEW ASSIGNMENT WAS MADE.
TLNE UCHN,SWP ;SKIP UNLESS CORGET WAS CALLED FROM SWAPPER.
JRST DIDLE4 ; SWAPPER GETS FAILURE (NO SKIP) RETURN
PUSHJ P,XPAND ;MARK THIS JOB AS EXPANDING. WILL BE SWAPPED OUT.
HLRZ TAC,JBTPAG(J) ;REASSIGN OLD CORE.
HRRZ LOC,JBTPAG(J)
CORGT1: MOVEI PROG,(LOC) ;FIRST PAGE OF NEW ASSIGNMENT
HRLI PROG,(TAC) ;NUMBER OF PAGES IN NEW ASSIGNMENT
MOVEI BLK,(TAC) ;NUMBER OF PAGES IN NEW ASSIGNMENT
MOVE UCHN,J ;SET USE BITS IN CORE TABLE
IFN FTPAGER,< PUSH P,DDB
LDB DDB,[POINT 1,JBTSTS(J),JWPPOS] ;DDB←WRITE PROTECT BIT
PUSHJ P,LMAPL ;SETUP PAGE MAP, WITH WRITE PROTECT
PUSHJ P,STRMAP ; SET FROM DDB
NOKL10,< CONO PAG,3 ;CLEAR ARS MAPPING USER PAGES >;NOKL10
IFKL10,< CONO KLPAG,@KLPCON >;IFKL10
POP P,DDB >;FTPAGER
PUSHJ P,CORSTG ;FIX CORTAB
SKIPN BLK,JBTPAG(J) ;GET OLD CORE ASSIGNMENT
JRST DIDLEA ;ON SWAP IN THERE'S NO OLD CORE.
CAIN LOC,(BLK) ;IS NEW CORE IN SAME PLACE AS OLD?
JRST DIDLE ;YES, DO NOT MOVE IT.
MOVCO1: HLRZ TAC1,BLK ;LENGTH OF OLD CORE IN PAGES.
CAILE TAC1,(TAC) ;SKIP UNLESS OLD CORE MORE THAN NEW.
MOVEI TAC1,(TAC) ;MOVE ONLY THE NEW, SHORTENED, CORE.
LSH TAC1,=9 ;CONVERT TO WORDS
ADDM TAC1,SHFWRD ;INCREMENT TOTAL NO. WORDS SHUFFLED
MOVEM BLK,PARBLK ;SAVE THIS FOR PARSER.
SETZM JBTPAG(J)
MOVEM J,PARSJB ;FOR PARSER, THE JOB BEING SHUFFLED
IFN FTHG,< PUSH P,HGCODE
HGMAC (30) >
MTRON (MTRSHF)
;RH(BLK)=SOURCE PAGE. LOC=DESTINATION PAGE, TAC1=NUMBER OF WORDS
IFE FTEXPG,<
LSH LOC,=9
ADD TAC1,LOC ;ADD IN NEW RELOC = ENDING ADDRESS OF BLT+1
MOVE TAC,LOC ;DESTINATION IS THE NEW RELOCATION
LSH BLK,=9
HRL TAC,BLK ;SOURCE IS THE OLD RELOCATION
↑SHFBLT:BLT TAC,-1(TAC1) ;LABEL FOR PARSER.
>;IFE FTEXPG
IFN FTEXPG,<
LSH TAC1,-=9 ;CONVERT WORD COUNT TO PAGES
MOVEI LOC,0 ;START AT USER ADDRESS 0.
BLTLP: PUSH P,TAC1 ;SAVE COUNT OF PAGES
MOVEI TAC1,SHFEXP
MOVEI TAC,(BLK) ;SOURCE PAGE NUMBER
PUSHJ P,ADDEMP ;MAP SOURCE PAGE ONTO SHFEXP
MOVE TAC,JBTMAP(J)
LSH TAC,=9
ADDI TAC,(LOC) ;DESTINATION PAGE NUMBER
MOVE TAC1,(TAC)
TLO TAC1,40000 ;MAKE SURE DESTINATION IS WRITEABLE
MOVEM TAC1,EXPGT+SHFEXP+1 ;MAP DESTINATION PAGE ONTO SHFEXP+1
MOVE TAC,[SHFEXP⊗9,,<SHFEXP+1>⊗9]
NOKL10,<CONO PAG,1 >;NOKL10
IFKL10,<CONO KLPAG,@KLPCON >;IFKL10
↑SHFBLT:BLT TAC,<SHFEXP+1>⊗9+777 ;LABEL FOR PARSER
SETZM EXPGT+SHFEXP ;DELETE MAP ENTRY FOR SOURCE
SETZM EXPGT+SHFEXP+1 ;AND FOR DESTINATION.
POP P,TAC1 ;RESTORE COUNT OF PAGES TO MOVE
ADDI LOC,1 ;ADVANCE THE (RELATIVE) DESTINATION PAGE NUMBER
ADDI BLK,1 ;ADVANCE THE (ABSOLUTE) SOURCE PAGE ADDRESS
SOJG TAC1,BLTLP
NOKL10,<CONO PAG,1 >;NOKL10
IFKL10,<CONO KLPAG,@KLPCON >;IFKL10
>;IFN FTEXPG
MTROFF (MTRSHF)
IFN FTHG,< POP P,HGCODE>
MOVEI LOC,(PROG) ;LOC←PAGE NUMBER OF NEW ASSIGNMENT - FOR DIDDLE
MOVE BLK,JBTPAG(J) ;BLK←OLD ASSIGNMENT - FOR DIDDLE
JRST DIDLE ;RECOMPUTE CORE PARAMETERS, SKIP RETURN TO USER
SUBTTL DIDDLE ;DIDLE, DIDLEA, DIDLE2
COMMENT $
Call DIDLE after allocating new core for a job that had old core
(i.e., after core may have been moved). Principal calls are (1)
expanding core size for a job, and (2) shuffling a job.
If the shuffled job is the current job, then hardware state needs to be
changed. DIDLE skip returns.
In the bad old days, the UUO level PDL was in the job data area. This
required that P in the dump acs, and sometimes the current exec P needed
to be diddled too. The new system prohibits direct reference to user
core, so all that has been flushed.
Call DIDLEA when core is not actually moved (i.e., shrunk in place,
or new core was allocated by the swapper). DIDLEA skip returns.
[For segments when we get to DIDLEA for the above two reasons, either
CORE2 is going to call AUPMAP or FININ will call AUPMAP from FINMST]
Call DIDLE2 with PROG, TAC, and LOC all zero, to release all core. Skips.
Call DIDLE4 to recompute parameters for the swapper (HOLEF, BIGHOL).
DIDLE4 does not skip.
Enter with PROG=new core assignment [JBTPAG format].
$
DIDLE: MOVE TAC,JBTSTS(J)
TLNN TAC,JSEG ;DID WE MOVE AN UPPER?
JRST DIDLE6 ;NO. THIS IS A LOWER
IFN FTPAGER,< PUSH P,JBTPAG(J)
MOVEM PROG,JBTPAG(J) ;STORE NEW CORE ASSIGNMENT FOR AUPMAP
CAME PROG,(P) ;(SKIP IF NOTHING REALLY MOVED)
PUSHJ P,AUPMAP ;FIX LOWERS' PAGE MAPS
POP P,JBTPAG(J) >;FTPAGER
IFN FTSTAT,< CAME PROG,JBTPAG(J)
PUSHJ P,CSTAT >
MOVEM PROG,JBTPAG(J) ;STORE NEW CORE ASSIGNMENT
PUSH P,J ;DOES THE CURRENT JOB USE THIS SEGMENT?
MOVE J,JOB(PID)
LDB TAC,PSEGN
CAME TAC,(P)
JRST DIDLE5 ;CURRENT JOB DOESN'T USE THIS SEGMENT.
JRST DIDLE7 ;CUREENT JOB USES THIS SEG. CHANGE APRMAP
;ENTER DIDLEA WHEN CORE WASN'T MOVED (SHRINK, OR NEW ASSIGNMENT FOR SWAPIN)
DIDLEA: MOVE TAC,JBTSTS(J)
TLNN TAC,JSEG ;SKIP IF THIS IS A SEGMENT
DIDLE6: PUSHJ P,DIDLEX ;ADJUST JOBREL IN USER'S AREA
DIDLE2: ;ENTER WITH PROG=0 TO RELEASE CORE.
IFN FTSTAT,< CAME PROG,JBTPAG(J)
PUSHJ P,CSTAT >
MOVEM PROG,JBTPAG(J) ;STORE NEW CORE ASSIGNMENT
MOVE TAC,JBTSTS(J)
TLNN TAC,JSEG
CAME J,JOB(PID) ;IS THIS CURRENT JOB?
JRST DIDLE9 ;NO, DO NOT ALTER STATE OF MONITOR
PUSH P,J
DIDLE7:
IFE FTPAGER,< PUSHJ P,GETPR ;GET JOB'S PROT-RELOC IN TAC
DATAO APR,TAC >;IFE FTPAGER
IFN FTPAGER,< ;CLEAR ARS MAPPING USER PAGES
NOKL10,< CONO PAG,3 >;NOKL10
IFKL10,< CONO KLPAG,@KLPCON >;IFKL10
>;FTPAGER
DIDLE5: POP P,J
DIDLE9: AOS (P) ;SET SKIP RETURN. NOTE DIDLE4 DOESN'T SKIP ANYMORE
IFKL10,<
PSYNC CSHCSC ;NOTE THAT THIS ROUTINE RUNS CH7/UUO ONLY
MOVSI TAC,CSHON ;LEAVE ONLY THE REASON BITS. ALLOW CSHSET
ANDCAM TAC,JBTCSH(J) ;TO TURN THE CACHE ON IF IT'S SUPPOSED TO.
XSYNC CSHCSC
PUSHJ P,CSHSET
>;IFKL10
DIDLE4: SETZB TAC,HOLEF ;CLEAR HOLE FLAG
PUSHJ P,HOLSRC ;IS THERE A NON-ZERO HOLE?
JRST COROK ;NO
ADDI LOC,(BLK) ;YES. FORM PAGE NUMBER ABOVE END OF HOLE
CAMGE LOC,MEMPAG ;SKIP IF HOLE IS AT THE TOP OF MEMORY.
MOVEM LOC,HOLEF ;SET HOLEF WITH PAGE NUMBER OF JOB ABOVE HOLE
COROK: MOVEI TAC,-1 ;FIND BIGGEST HOLE (ASK FOR TOO MUCH!)
PUSHJ P,HOLSRC
JFCL
MOVEM AC2,BIGHOLE ;SIZE OF BIGGEST HOLE (IN PAGES)
IFN FTCORBUG,< PUSHJ P,CORTCK > ;CHECK FOR CORTAB - JBTADR CONSISTENCY
POPJ P, ;(THIS WILL SKIP, EXCEPTING CALLS TO DIDLE4)
DIDLEX: PUSHJ P,MAPSET
HLRZ TAC,PROG ;STORE JOBREL OF NEW CORE ASSIGNMENT
LSH TAC,=9
SUBI TAC,1
XCTR XW,[HRRZM TAC,JOBREL] ;ALWAYS SET JOB DATA AREA W/PROTECTION
POPJ P, ;RETURN FROM DIDLEX (THROUGH MAPSET)
IFN FTSTAT,<
;CALL WITH PROG=NEW CORE, JBTPAG(J)=OLD CORE
CSTAT: MOVE TAC,JBTSTS(J)
TLNE TAC,SWP ;IF SWAPPER,
JRST CSTAT0 ;THEN IS ONLY POSITION CHANGE
MOVE TAC,PROG
XOR TAC,JBTPAG(J)
TLNN TAC,-1 ;CHANGE IN SIZE?
JRST CSTAT1 ;NO CHANGE IN SIZE.
HLRZ TAC,PROG ;TAC←NEW SIZE
LSH TAC,6
IORI TAC,CSZSTA
PUSHJ P,STAPUT ;SEND SIZE
CSTAT1: JUMPE PROG,CPOPJ ;REPORT ONLY PROT IF CORE 0
MOVE TAC,PROG
XOR TAC,JBTPAG(J) ;ANY POSITION CHANGE?
TRNN TAC,-1
POPJ P,
CSTAT0: MOVEI TAC,CPSSTA ;REPORT POSITION CHANGE
PUSHJ P,STAPUT
HRRZ TAC,PROG
JRST STAPTT ;REPORT NEW POSITION.
>;IFN FTSTAT
SUBTTL HOLSRC
;ROUTINE TO FIND HOLE BIG ENOUGH FOR REQUEST
;CALL: MOVE TAC,<NUMBER OF PAGES WANTED>
; PUSHJ P,HOLSRC
; RETURN1 ;NO HOLES BIG ENOUGH. AC2=SIZE OF LARGEST HOLE (IN PAGES)
; RETURN2 ;BLK SET TO NUMBER OF PAGES IN THE HOLE
; ;LOC SET TO FIRST PAGE IN THE HOLE
;USES TAC1
HOLSRC: SETZB AC2,CORTLX ;LARGEST HOLE SIZE = 0. TOTAL FREE = 0
MOVE LOC,LOKPAG ;START SCAN AT BOTTOM OF UNLOCKED CORE.
CORHOL: TDZA BLK,BLK ;LOOK FOR A HOLE. INITIAL SIZE IS ZERO. SKIP
CORHO0: ADDI BLK,1 ;INCREMENT SIZE OF PRESENT HOLE
CORHO1: CAML LOC,MEMPAG ;ARE WE WITHIN LOW CORE?
AOJA LOC,CORHO2 ;NO. SIMULATE END OF THE PRESENT HOLE.
IFE FTPAGER,< PUSH P,TAC
PUSHJ P,CORGBP
LDB TAC1,TAC
POP P,TAC >;IFE FTPAGER
IFN FTPAGER,< LDB TAC1,COREP ;(INDEX BY LOC) >;IFN FTPAGER
ADDI LOC,1 ;ADVANCE TO NEXT PAGE.
JUMPE TAC1,CORHO0 ;JUMP IF THIS PAGE IS FREE
JUMPE BLK,CORHO1 ;PAGE IN USE. JUMP IF WE'RE NOT AT END OF A HOLE
CORHO3: CAMLE BLK,AC2 ;END OF A HOLE. IS THIS ONE THE BIGGEST SO FAR?
MOVE AC2,BLK ;YES, SAVE IN AC2
ADDM BLK,CORTLX
CAMGE BLK,TAC ;IS THIS HOLE BIG ENOUGH FOR THIS REQUEST?
JRST CORHOL ;NO, KEEP LOOKING FOR HOLES
SUBI LOC,1(BLK) ;YES, SET LOC TO FIRST PAGE IN THE HOLE
JRST CPOPJ1
CORHO2: JUMPN BLK,CORHO3 ;SIMULATE END OF HOLE SEEN
MOVE TAC1,CORTLX
CAMN TAC1,CORTAL
POPJ P, ;NOT INSIDE OF A HOLE. RETURN NOW.
PUSHACS
PUSHJ P,DISMES
ASCIZ /CORTAL INCONSISTENT AT HOLSRC
/
PUSHJ P,DISFLU
POPACS
PUSHJ P,WDDTCAL
MOVEM TAC1,CORTLX
POPJ P,
;CORCHK AND CORTCK -- CHECK CORTAL AGAINST CORTAB AND CHECK CORTAB AGAINST WORLD
IFN FTCORBUG,<
CORCHK: PUSH P,TAC ;MAKE SURE CORTAB AND CORTAL ARE CONSISTENT
PUSH P,AC2
PUSH P,AC1
PUSH P,TAC1
PUSH P,LOC
MOVE LOC,LOKPAG
MOVEI AC2,0 ;COUNT FREE PAGES ABOVE LOKTOP
CORCH1: CAML LOC,MEMPAG
JRST CRCH1A
PUSHJ P,CORGBP
ADDI LOC,1
LDB TAC,TAC
JUMPN TAC,CORCH1
AOJA AC2,CORCH1 ;COUNT A FREE PAGE
CRCH1A: CAMN AC2,CORTAL
JRST CORCH8 ;RIGHT ANSWER
PUSHACS
PUSHJ P,DISMES
ASCIZ /CORTAL = /
MOVE TAC,CORTAL
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ /,SHOULD BE = /
MOVE TAC,AC2-17(P)
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ /; CALLER'S ADDRESS = /
HRRZ TAC,-26(P)
PUSHJ P,DISLOC
PUSHJ P,DISCRLF
PUSHJ P,DISFLU
PUSHJ P,WDDTCALL
POPACS
MOVEM AC2,CORTAL
CORCH8:
IFN FTHPSG,<
MOVE LOC,FHUPAG
MOVEI AC2,0 ;COUNT FREE PAGES IN HIGH CORE.
CORC8A: CAML LOC,LHUPAG
JRST CRCH8B
LDB TAC,COREP
ADDI LOC,1
JUMPN TAC,CORC8A
AOJA AC2,CORC8A ;COUNT A FREE PAGE
CRCH8B: CAMN AC2,CORHTL
JRST CORC8C ;RIGHT ANSWER
PUSHACS
PUSHJ P,DISMES
ASCIZ /CORHTL = /
MOVE TAC,CORHTL
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ /,SHOULD BE = /
MOVE TAC,AC2-17(P)
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ /; CALLER'S ADDRESS = /
HRRZ TAC,-26(P)
PUSHJ P,DISLOC
PUSHJ P,DISCRLF
PUSHJ P,DISFLU
PUSHJ P,WDDTCALL
POPACS
MOVEM AC2,CORHTL
CORC8C:
>;FTHPSG
POP P,LOC
POP P,TAC1
POP P,AC1
POP P,AC2
POP P,TAC
POPJ P,
CORTCK: PUSH P,AC1
PUSH P,AC2
PUSH P,AC3
PUSH P,LOC
PUSH P,J
PUSH P,TAC
PUSH P,TAC1
MOVE J,JOBNM1
CORCKL: MOVE AC2,JBTSTS(J)
TLNE AC2,JNA ;IS THERE A JOB HERE?
SKIPN AC2,JBTPAG(J) ;YES. IS IT INCORE?
JRST CORCKN ;NO JOB OR NO CORE
HRRZ LOC,AC2 ;ADDRESS OF HIS FIRST PAGE
HLRZ AC2,AC2 ;PAGE COUNT
CORCK1: PUSHJ P,CORGBP
ADDI LOC,1
LDB AC3,TAC
CAIE AC3,(J)
JRST CORCKC ;CORTAB ISN'T MARKED ACCORING TO THIS JBTPAG
SOJG AC2,CORCK1 ;DECREMENT COUNT OF JOB'S PAGES
CORCKN: SOJG J,CORCKL ;LOOK THRU ALL JOBS
MOVE LOC,SYSPAG ;FIRST PAGE OF USER CORE.
CORCK0: CAML LOC,MEMPAG ;SKIP UNLESS WE'RE AT THE END
JRST CORCKZ ;END. TEST OK.
PUSHJ P,CORGBP ;LOOK AT ALL USER STG CORTAB ENTRIES
LDB J,TAC
JUMPE J,[AOJA LOC,CORCK0] ;HOLE. ADVANCE TO NEXT PAGE
CAMLE J,JOBNM1
JRST CORCKD ;ILLEGAL BYTE IN CORTAB
MOVE AC1,JBTPAG(J)
CAIE LOC,(AC1)
JRST CORCKE ;NOT FIRST BLOCK OF THIS JOB!
HLRZ AC2,AC1 ;AC2←PAGE COUNT OF THIS JOB.
ADDI LOC,(AC2) ;ADVANCE PAST THIS JOB.
JRST CORCK0 ;LOOK FOR OTHR THINGS.
CORCKZ: POP P,TAC1
POP P,TAC
POP P,J
POP P,LOC
POP P,AC3
POP P,AC2
POP P,AC1
JRST CORCHK ;NOW CHECK CORTAL
CORCKC: JSP TAC1,CORCKX ;BLOCK CLAIMED IN JBTPAG BUT NOT IN CORTAB
CORCKD: JSP TAC1,CORCKX ;ILLEGAL VALUE OF CORTAB BYTE
CORCKE: JSP TAC1,CORCKX ;BLOCK WASN'T FIRST BLOCK OF A JOB
CORCKX: PUSHACS
PUSHJ P,DISMES
ASCIZ /LOSSAGE AT CORCHK -- GET A WIZARD. THE WINNING ENTRY IS /
HRRZ TAC,TAC1-17(P)
SUBI TAC,CORCKC+1
PUSHJ P,DISOCT
PUSHJ P,DISCRLF
PUSHJ P,DISFLU
PUSHJ P,DDTCAL
POPACS
JRST CORCKZ
>;IFN FTCORBUG
SUBTTL CORSTG - SET AND CLEAR CORE USE TABLE ;CORGBP,CORSGT
LOSYS
;CALL: MOVE UCHN,<JOB NUMBER, OR OTHER CODE> ;TO SET TABLE
; MOVEI UCHN,0 ;TO CLEAR TABLE
; MOVE BLK,<NUMBER OF PAGES TO AFFECT>
; MOVE LOC,<NUMBER OF FIRST AFFECTED PAGE>
; PUSHJ P,CORSTG
; <RETURNS WITH BLK=0>
↑CORSTG: ;THE EXTERNAL CALLS ARE FROM REMAP IN UUOCON
PUSH P,TAC ;SAVE HIGHEST LOC. BEING REQUESTED
PUSH P,LOC ;SAVE STARTING ADDRESS
JUMPE UCHN,.+2 ;UPDATE NO OF FREE BLOCKS
MOVNI BLK,(BLK) ;DECREASE IF SETTING BITS
CAML LOC,LOKPAG ;IF THIS IS A CALL IN LOCKED CORE, LOCK AND
;UNLOCK ARE RESPONSIBLE FOR DIDDLING CORTAL - REG
ADDM BLK,CORTAL ;INCREASE IF CLEARING,DECREASE IF SETTING BITS
MOVM BLK,BLK ;GET MAG. OF NO. OF BLOCKS INVOLVED
CORST1:
IFE FTPAGER,< PUSHJ P,CORGBP ;MAKE A BYTE POINTER >
IFN FTPAGER,< MOVE TAC,COREP ;GET A BYTE POINTER (INDEX OF LOC)>
LDB TAC1,TAC ;GET OLD BYTE
JUMPE UCHN,CORST9 ;LOOK FOR CONFLICTS, JUMP IF CLEARING
JUMPN TAC1,CORST2 ;SETTING, JUMP IF ALREADY SET (ERROR)
JRST CORSTD ;SETTING AND NOT ALREADY SET (O.K.)
CORST9: JUMPN TAC1,CORSTD ;CLEARING, JUMP IF SET (O.K.)
CORST2: PUSHACS ;LOSER.
PUSHJ P,DISDATE
PUSHJ P,DISMES
ASCIZ /CORTAB LOSES AT CORSTG. OLD CLAIM= /
MOVE TAC,TAC1-17(P) ;GET THE ARGUMENT
PUSHJ P,DISDCP ;TYPE DECIMAL WITH PERIOD
PUSHJ P,DISMES
ASCIZ / NEW CLAIM = /
MOVE TAC,UCHN-17(P) ;GET NEW CLAIM
PUSHJ P,DISDCP ;TYPE DECIMAL W/PERIOD
PUSHJ P,DISCRLF
POPACS
CORSTD: DPB UCHN,TAC ;STORE NEW CORE USE BITS.
ADDI LOC,1 ;ADVANCE TO NEXT PAGE
SOJG BLK,CORST1
IFN FTCORBUG,< PUSHJ P,CORCHK > ;MAKE SURE CORTAB AND CORTAL ARE RIGHT
POP P,LOC
JRST TPOPJ ;RESTORE TAC, AND POPJ
IFE FTPAGER,<
COREP: POINT 9,CORTAB,8
POINT 9,CORTAB,17
POINT 9,CORTAB,26
POINT 9,CORTAB,35
;CALL WITH LOC=PAGE NUMBER. RETURNS TAC=BYTE POINTER FOR LDB/DPB. CLOBBERS TAC1
↑CORGBP: ;MAKE A BYTE POINTER TO CORTAB (PARSER CALLS THIS)
MOVE TAC,LOC ;ADDRESS OF FIRST BLOCK
CORGB1: IDIVI TAC,4 ;ENTER HERE WITH TAC SET UP.
ADD TAC,COREP(TAC1) ;FORM BYTE POINTER
POPJ P,
>;IFE FTPAGER
IFN FTPAGER,<
COREP: POINT 9,CORTAB(LOC),26 ;CORTAB IS REALLY THE CST
↑CORGBP:MOVEI TAC,(LOC)
CORGB1: ADD TAC,COREP
TLZ TAC,17 ;FLUSH INDEX FIELD
POPJ P,
>;IFN FTPAGER
;CORSGT - COMPUTE SIZE (IN WORDS) OF GIVEN JOB.
;CALL: MOVE TAC1,<JOB NUMBER>
; PUSHJ P,CORSGT ;CHANGES ONLY TAC1
; <RETURNS TAC1=CORE SIZE OF JOB>
↑CORSGT:PUSH P,TAC ;SAVE TAC
MOVE TAC,JBTSTS(TAC1) ;GET JOB STATUS
TLNN TAC,SWP ;SKIP IF ON DISK,
JRST CORSG1 ;HE'S IN CORE.
PUSH P,J
MOVEI J,(TAC1)
LDB TAC1,IMGIN
POP P,J
LSH TAC1,=9 ;SHIFT TO MAKE WORDS.
JRST TPOPJ ;RESTORE TAC AND RETURN.
CORSG1: HLRZ TAC1,JBTPAG(TAC1)
LSH TAC1,=9
JRST TPOPJ
SUBTTL GETPR GET A JOB'S PROTECTION-RELOCATION
↑GETPR: PUSH P,DAT ;SAVE SOME ACCUMULATORS
PUSH P,TAC1
SKIPN TAC,J ;FOR JOB 0,
JRST GETPR1 ;WE SUPPLY A ZERO FOR LASTPR AND FOR DATAO APR,
MOVE TAC,JBTPAG(J) ;START WITH THE MAIN PART
LSH TAC,=9 ;SHIFT TO FORM RELOCATION OF LOWER
SUB TAC,[1,,0] ;CORRECT THE PROTECTION
ANDCM TAC,[1777,,1777]
LDB DAT,PSEGN
JUMPE DAT,GETPR4 ;IF NO UPPER SEGMENT, WE ARE DONE
MOVE TAC1,JBTSTS(DAT);HE HAS AN UPPER, IS IT WRITE-PROTECTED?
TLNE TAC1,JWP
TLO TAC,1 ;YES, SET WRITE-PROTECT BIT
SKIPN TAC1,JBTPAG(DAT);PROT,,RELOC OF UPPER
JRST GETPR1 ;UPPER NOT IN CORE
LSH TAC1,=9
SUB TAC1,[1,,0]
GETPR5: HLRZ DAT,JBTPAG(J) ;PROT OF LOWER
LSH DAT,=9
SUBI DAT,1
CAIGE DAT,400000 ;SKIP IF LOWER IS BIGGER THAN 128K
JRST GETPR3 ;LOWER LE 128K, UPPER STARTS AT 400000
SUBI TAC1,(DAT) ;FUDGE RELOCATION BY RIGHT AMOUNT
HRLZ DAT,DAT ;PROT OF LOWER + SIZE OF UPPER GIVES
ADD TAC1,DAT ; PROT OF UPPER
JRST GETPR2
GETPR3: TRC TAC1,400000 ;REL OF UPPER (FROM JBTADR) CORRESP TO 400000
GETPR2: TLO TAC1,400000
LSH TAC1,-9
AND TAC1,[776,,776]
IOR TAC,TAC1 ;MERGE TWO RELOCATIONS
GETPR1: POP P,TAC1
POP P,DAT
IFE FTPAGER,< MOVEM TAC,LASTPR(PID) >;NOT FTPAGER - SAVE LAST PROT-RELOC ISSUED
POPJ P,
GETPR4: SKIPN TAC1,JBTPR2(J) ;IS DOING PEEK-POKE STUFF?
JRST GETPR1 ;NO
TRNE TAC1,4 ;IS IT GETHI HACK
JRST GETPR1 ;YES. WE ARE DONE (GETHI USES MAP, NOT PROT-REL)
TLNE TAC1,1 ;IS IT TO BE WRITE PROTECTED?
TLO TAC,1 ;YES
TRZN TAC1,1 ;IS IT TO BE RELATIVE TO HIS CORE IMAGE?
JRST GETPR5 ;NO.
PUSH P,TAC ;YES, CHECK TOP OF HIS CORE IMAGE
HLRZ TAC,TAC1 ;PROTECTION HE IS REQUESTING
IORI TAC,1777 ;MAKE IT HONEST
HLRZ DAT,JBTPAG(J) ;HIS JOB'S PROTECTION
LSH DAT,=9
SUBI DAT,1(TAC1) ;HOW FAR FROM NEW RELOCATION TO TOP OF CORE IMAGE.
JUMPL DAT,GETPR6 ;NOT IN HIS CORE, HE DOESN'T GET TO HAVE AN UPPER
CAMLE DAT,TAC ;IS HE REQUESTING TO MUCH?
MOVE DAT,TAC ;NO, USE WHAT HE GAVE US
POP P,TAC ;GET BACK LOWERS PROT. RELOC.
HRL TAC1,DAT ;SET NEW PROT. FOR PR2
ADDI TAC1,(TAC) ;AND RELOCATE IT
JRST GETPR5 ;AND NOW IT LOOKS LIKE AN UPPER
GETPR6: POP P,TAC
TLZ TAC,1
JRST GETPR1
SUBTTL RELOCA
HISYS
;THIS HERE IS A ROUTINE TO ADDRESS CHECK AND RELOCATE
;A USER ADDRESS. IT MAKES USE OF UPPER SEGMENTS AND
;THE PEEK-POKE FEATURE (JBTPR2).
;CALLING:
; MOVE J,<NUMBER OF JOB IN QUESTION>
; MOVE TAC1,<ADDRESS TO CHECK AND RELOCATE>
; PUSHJ P,RELOCA
; <ILLEGAL ADDRESS>
; <LEGAL ADDRESS>
;UPON SUCCESS RETURN TAC1 CONTAINS THE ABSOLUTE ADDRESS
;THE SIGN BIT IS SET IF THIS ADDRESS IS WRITE PROTECTED
;FROM THE USER (THIS INCLUDES THE PROTECTED PART FROM 0-JOBPFI).
;AC1 IS NOW SET-UP FOR A CALL ON RELOCB.
↑↑RELOCA:
HRRZ TAC1,TAC1 ;CLEAR CONFUSING BITS!
PUSH P,TAC ;SAVE AN AC
MOVEI TAC,JOBPFI ;USER'S LOWEST LEGAL IO ADDRESS.
HLL TAC,UUOPC(J) ;USER OR EXEC OPERATION?
TLNN TAC,USRMOD ;SKIP IF USER OP
HRRI TAC,JOBSAV ;MONITOR GETS TO DO IO AT LOWER ADDRESSES.
CAIGE TAC1,(TAC) ;IS THIS ADDRESS BELOW PROTECTED PART?
TLO TAC1,400000 ;SET WRITE PROTECTED ACCESS
HLRZ TAC,JBTPAG(J) ;GET SIZE OF LOWER
LSH TAC,=9
CAIGE TAC,(TAC1) ;IS IT OUTSIDE LOWER?
JRST RELOC1 ;YES, THIS IS HARDER
HRRZ AC1,JBTPAG(J) ;FIRST PAGE NUMBER
LSH AC1,=9 ;RELOCATION VALUE
ADD TAC1,AC1 ;RELOCATE. (POSSIBLE DATA IN LH OF TAC)
MOVEI AC1,JBTPAG(J) ;POINT TO THE RELOCATION WORD WE USED.
JRST TPOPJ1 ;PUT BACK TAC AND SKIP
RELOC1: LDB AC1,PSEGN ;CHECK FOR UPPER SEGMENT
PUSH P,DAT ;SAVE ANOTHER AC.
JUMPE AC1,RELOC2 ;NONE, CHECK PEEK-POKE
MOVSI TAC,JWP ;CHECK WRITE PROTECT
TDNE TAC,JBTSTS(AC1)
TLO TAC1,400000 ;WRITE PROTECTED
HLRZ DAT,JBTPAG(AC1) ;NUMBER OF PAGES IN UPPER.
LSH DAT,=9 ;NUMBER OF WORDS IN UPPER.
HLRZ TAC,JBTPAG(J) ;NUMBER OF PAGES IN THE LOWER
CAIGE TAC,400 ;SKIP IF LOWER IS 256 PAGES OR LARGER
MOVEI TAC,400 ;UPPER STARTS AT PAGE 400
LSH TAC,=9 ;UPPER'S STARTING WORD ADDRESS.
SUB TAC1,TAC ;ADJUST REFERENCE - RELATIVE ADDRESS IN THE UPPER.
TLNE TAC1,377777 ;UNDERFLOW?
JRST RELOC4 ;YES, BETWEEN UPPER AND LOWER!
CAIG DAT,(TAC1) ;TOO BIG?
JRST RELOC4 ;TOO BIG. AVOID SKIP RETURN
HRRZ TAC,JBTPAG(AC1)
LSH TAC,=9
ADD TAC1,TAC
MOVEI AC1,JBTPAG(AC1) ;POINT TO THE RELOCATION WORD WE USED.
AOS -2(P) ;NEED TO RESTORE DAT, TAC, AND SKIP.
RELOC4: POP P,DAT
JRST TPOPJ ;LOSE
RELOC2: SKIPN AC1,JBTPR2(J) ;IS HE DOING PEEK-POKE
JRST RELOC4 ;NO. LOSE. RESTORE DAT, TAC AND RETURN
TRNE AC1,4 ;IS IT GETHI HACK
JRST RELOC4 ;YES, LOSE.
TLOE AC1,1 ;IS HE WRITE PROTECTED(SET BIT FOR COMPARE)
TLO TAC1,400000 ;YES
TRZN AC1,1 ;IS THIS A RELATIVE MAPPING?
JRST RELC2A ;NOT A RELATIVE UPPER
HLRZ TAC,JBTPAG(J) ;SIZE OF LOWER
LSH TAC,=9 ;SIZE OF LOWER IN WORDS
SUBI TAC,(AC1) ;-RELATIVE RELOCATION = MAX. REL. WC OF UPPER
SOJL TAC,RELOC4 ;ERROR IF REL. PROT. OF UPPER IS TOO SMALL
HRRZ DAT,JBTPAG(J)
LSH DAT,=9 ;STARTING ADDRESS OF LOWER
ADDI AC1,(DAT) ;AC1←STARTING ADDRESS OF UPPER
HRL AC1,TAC ;AC1←PROT OF UPPER IN LEFT
RELC2A: MOVEI DAT,JBTPR2(J) ;POINT TO THE PROT-REL WORD BEING USED.
RELOC3: HLRZ TAC,JBTPAG(J) ;NUMBER OF PAGES IN THE LOWER
CAIGE TAC,400 ;SKIP IF LOWER IS 256 PAGES OR LARGER
MOVEI TAC,400 ;UPPER STARTS AT PAGE 400
LSH TAC,=9 ;UPPER'S STARTING WORD ADDRESS.
SUB TAC1,TAC ;ADJUST REFERENCE - RELATIVE ADDRESS IN THE UPPER.
TLNE TAC1,377777 ;UNDERFLOW?
JRST RELOC4 ;YES, BETWEEN UPPER AND LOWER!
HLRZ TAC,AC1 ;GET PROT.
CAIGE TAC,(TAC1) ;TOO BIG?
JRST RELOC4 ;TOO BIG. AVOID SKIP RETURN
ADDI TAC1,(AC1)
MOVE AC1,DAT ;RETURN IN AC1 THE ADDRESS OF THE PROT-REL WORD
AOS -2(P) ;NEED TO RESTORE DAT, TAC, AND SKIP.
POP P,DAT
JRST TPOPJ ;LOSE
;USE THIS ROUTINE AFTER CALLING RELOCA ONCE TO ASSURE
;THAT THE ADDRESS YOU ARE CHECKING IS IN THE SAME
;SEGMENT AS THE LAST ONE YOU CHECKED. DON'T CLOBBER
;AC1 BETWEEN CALLS ON RELOCA AND RELOCB
;CALLING:
; MOVE J,<NUMBER OF JOB IN QUESTION>
; MOVE TAC1,<ADDRESS YOU WISH CHECKED>
; PUSHJ P,RELOCB
; <ILLEGAL ADDRESS OR NOT IN SAME SEGMENT AS AC1>
; <LEGAL ADDRESS AND IN RIGHT SEGMENT>
↑↑RELOCB:
PUSH P,AC1 ;SAVE PROT RELOC WE USED LAST!
PUSHJ P,RELOCA ;DO THE RELOC THING
JRST RELOC5
POP P,(P)
EXCH AC1,1(P)
CAMN AC1,1(P) ;DID RELOCA USE PROT RELOC WE WANTED?
AOS (P) ;YES, SUCCESS
POPJ P,
RELOC5: POP P,AC1
POPJ P, ;LOSE
↑↑RELOCC:
PUSHJ P,RELOCA
POPJ P,
TLNN TAC1,17
AOS (P)
POPJ P,
↑↑RELOCD:
PUSHJ P,RELOCB
POPJ P,
TLNN TAC1,17
AOS (P)
POPJ P,
SUBTTL LOCK AND UNLOCK UUOS.
PRINTX HIUSER BUGS
↑UNLOKC:MOVEI J,(DAT) ;CALLED FROM CLOCK RQ AT ESTOP4
↑UNLOCK:PUSH P,TAC
MOVEI TAC,JLOCK
TDNN TAC,JBTSTS(J) ;IS JOB LOCKED IN AT ALL?
JRST TPOPJ ;NO. THIS IS EASY.
PUSH P,PROG
ANDCAM TAC,JBTSTS(J) ;UNLOCK HIM.
IFN FTSTAT,< MOVEI TAC,LOKSTA
PUSHJ P,STAPUT >;FTSTAT
MOVE PROG,JBTPAG(J) ;GET THE ADDRESS OF THIS JOB.
HLRZ TAC,PROG
ADDI TAC,(PROG) ;COMPUTE ADDRESS ABOVE THIS JOB.
CAME TAC,LOKPAG ;SAME AS LOKTOP?
JRST UNLOK4 ;NO. SIZE OF LOCKED CORE DOESN'T DIMINISH
UNLOK0: PUSH P,TAC1
HRRZ PROG,PROG ;PAGE NUMBER OF BOTTOM OF NEW UNLOCKED AREA.
UNLOK1: MOVEI TAC,-1(PROG) ;LOOK 1 PAGE FURTHER DOWN.
PUSHJ P,CORGB1 ;GET A BYTE POINTER
LDB TAC1,TAC ;LOAD CORE CODE.
JUMPE TAC1,UNLOK2 ;CORE IS FREE. (GIVE BACK TO CORTAL)
MOVEI TAC,JLOCK
CAIGE TAC1,101 ;CORE IN SYSTEM?
TDNE TAC,JBTSTS(TAC1) ;NO. CORE BELONGS TO UNLOCKED USER?
JRST UNLOK3 ;SYSTEM CORE OR LOCKED USER.
JRST .+2
UNLOK2: AOS CORTAL ;UNCLAIMED BLOCK: INCREMENT CORTAL
SOJA PROG,UNLOK1
UNLOK3: HRRZM PROG,LOKPAG
LSH PROG,=9
MOVEM PROG,LOKTOP
IFN FTCORBUG,< PUSHJ P,CORCHK > ;MAKE SURE CORTAB AND CORTAL ARE CONSISTENT
POP P,TAC1 ;RESTORE AC'S
UNLOK4: POP P,PROG
JRST TPOPJ
LOCK0: JSP TAC,UUOMES
ASCIZ /Can't LOCK with segment
/
↑LOCK: LDB TAC1,PSEGN
JUMPN TAC1,LOCK0
SKIPE LOCKNO
CAMN J,LOCKNO
JRST LOCK1
MOVEI TAC,JIFSEC/2 ;CODE CAN'T BE REENTERED, SO
PUSHJ P,SLEEPT ;LET THIS GUY WAIT.
JRST LOCK
LOCK0A: MOVEI TAC,0 ;DELAY UNTIL HIS IO STOPS
PUSHJ P,SLEEP
JRST LOCK
LOCK1: PUSHJ P,ANYACT ;WAIT UNTIL IO STOPS.
JRST LOCK0A
MOVEI AC2,JLOCK ;NOW WE DECIDE WHERE TO PUT THIS TURKEY.
TDNE AC2,JBTSTS(J) ;ARE WE LOCKED ALREADY?
PUSHJ P,UNLOCK ;YES. UNLOCK FIRST. (SHUFFLES IF POSSIBLE)
LOCK2A: MOVE LOC,FUPAG ;LOWEST POSSIBLE LOC OF HOLE.
CAML LOC,LOKPAG ;TOP OF LOCKED SPACE.
JRST LOCK2 ;LOC CONTAINS PAGE WHERE TO LOCK.
LOCK1A: TDZA BLK,BLK ;SIZE OF THIS HOLE.
LOCK1B: ADDI BLK,1 ;INCREMENT SIZE OF THIS HOLE.
LOCK1C: CAML LOC,LOKPAG ;PASSED THE LOCKED PART?
JRST LOCK1D ;YES. SEE IF IT WAS IN A HOLE.
PUSHJ P,CORGBP ;MAKE A BYTE POINTER
LDB TAC1,TAC ;PICKUP CORE USE BITS
ADDI LOC,1
JUMPE TAC1,LOCK1B ;JUMP IF STILL IN HOLE.
CAIGE TAC1,101 ;SKIP IF THIS IS NOT A JOB
TDNE AC2,JBTSTS(TAC1) ;SKIP IF JOB IS UNLOCKED
JRST .+2 ;IN SYSTEM OR IN LOCKED JOB.
JRST LOCK1B ;UNLOCKED JOB IS A LOGICAL HOLE.
JUMPE BLK,LOCK1C ;NOT IN HOLE. JUMP IF THERE WAS NO HOLE.
HRLZ TAC,JBTPAG(J) ;TAC←SIZE OF HOLE WE NEED.
CAIG BLK,(TAC) ;SKIP IF HOLE IS BIG ENOUGH.
JRST LOCK1A ;NOT BIG ENOUGH.
SUBI LOC,1(BLK) ;COMPUTE FIRST LOCATION OF HOLE.
JRST LOCK2 ;LOC←FIRST PAGE OF DESIRED HOLE
LOCK1D: SUBI LOC,(BLK) ;DECREASE FOR HOLE AT TOP.
LOCK2: HLL LOC,JBTPAG(J) ;LOC←DESIRED NEW JBTPAG
MOVEM LOC,LOKPOS ;SAVE ADDRESS OF THE HOLE.
CAMN LOC,JBTPAG(J) ;SAME AS WHERE WE ARE NOW?
JRST LOCK4 ;WE'RE IN LUCK. (LOCK)
PUSHJ P,LOCK5 ;SEE IF WE CAN SHUFFLE TO THE RIGHT PLACE.
JRST LOCK3 ;NO. LET THE CLOCK SWAP JOBS OUT.
;HERE WE HAVE TO MOVE OURSELVES IN.
MOVE PROG,JBTPAG(J)
HLRZ TAC,JBTPAG(J) ;DESIRED CORE SIZE
HRRZ LOC,JBTPAG(J) ;FIRST PAGE OF OLD ASSIGNMENT
HLRZ BLK,JBTPAG(J) ;NUMBER OF PAGES IN OLD ASSIGNMENT
IFN FTPAGER,< PUSHJ P,LMAPL ;RELEASE OLD PAGE TABLE ENTRIES
SETZM (TAC1) >;FTPAGER
MOVEI UCHN,0
PUSHJ P,CORSTG ;FREE OLD CORE.
HRRZ LOC,LOKPOS ;THIS IS THE ADDRESS OF THE NEW ASSIGNMENT.
PUSHJ P,CORGT1 ;MAKE IT SHUFFLE
JFCL ;ALWAYS SKIPS.
LOCK4:
IFN FTSTAT,< MOVEI TAC,LOKSTA+100
PUSHJ P,STAPUT >;FTSTAT
MOVEI TAC,JLOCK
IORM TAC,JBTSTS(J) ;TELL THEM WE'RE LOCKED IN.
MOVE PROG,JBTPAG(J) ;JOB IS NOW IN THE RIGHT PLACE.
HLRZ TAC,PROG ;GET PROT
ADDI TAC,(PROG) ;FIRST ADDRESS ABOVE THIS JOB
CAMG TAC,LOKPAG ;IS THIS GREATER THAN OLD LOKTOP?
JRST LOCK99 ;NO. THEN THERE'S NOTHING SPECIAL.
;CORTAL SHOULD BE OK. JOB WAS MOVED TO CORE WHICH WASN'T LOCKED CORE AT THAT TIME.
MOVEM TAC,LOKPAG ;STORE NEW FIRST UNLOCKED PAGE
LSH TAC,=9
MOVEM TAC,LOKTOP
LOCK99: PUSHJ P,SPWCNT ;CONTINUE HIS SPACEWAR JOB IF SUSPENDED
SETZM LOCKNO ;CLEAR THIS.
MOVE TAC,JBTPAG(J)
LSH TAC,=9
SUB TAC,[1,,0]
JRST STOTAC
LOCK5: HRRZ LOC,LOKPOS ;GET BASE LOCATION
HLRZ AC3,LOKPOS ;AND THE PROTECTION.
LOCK5A: PUSHJ P,CORGBP ;MAKE A BYTE POINTER IN TAC.
LDB TAC1,TAC ;GET CORE USE BITS
CAIN TAC1,(J) ;SAME AS OUR JOB
JRST CPOPJ1 ;YES. THEN WE CAN MOVE IN.
JUMPN TAC1,CPOPJ ;SOME ONE IS THERE. WE HAVE TO WORK HARD.
ADDI LOC,1
SOJG AC3,LOCK5A
JRST CPOPJ1 ;WE'RE ALL FREE.
LOCK3: MOVEM J,LOCKNO ;TELL THE SWAPPER TO FOREGO SWAPIN.
PUSHJ P,LOCKPL ;PLANT CLKRQ FOR LOCK.
MOVNI TAC,IOWQ ;REQUE THIS JOB TO IOWQ
MOVEM TAC,JOBQUE(J)
PUSHJ P,WSCHED ;WAIT FOR REACTIVATION
CAME J,LOCKNO ;AVOID ↑C CONTINUE HANGUP
JRST LOCK ;REENTER THE LOCK RESOURCE
MOVE LOC,LOKPOS
JRST LOCK2A ;SEE IF ALL GOOD THINGS HAVE HAPPENED.
LOCK3A: ;HERE AT CLOCK LEVEL.
SKIPGE FSCLKF ;FREE STORAGE DOING IT TOO?
JRST LOCKPL ;YES. WAIT FOR IT TOO.
SKIPN FINISH
SKIPE FORCE
JRST LOCKPL ;WAIT FOR SWAPPER TO BE IDLE.
SKIPE J,LOCKNO
SKIPL JBTSTS(J)
JRST LOCK3C ;FLUSH CLOCK RQ IF JOB NOT THERE.
PUSHJ P,LOCK5 ;SEE IF THERE'S A HOLE YET.
JRST LOCK3B ;NOT YET.
MOVNI TAC,TQ
MOVEM TAC,JOBQUE(J) ;SET JOB TO RUN AGAIN
JRST REQUE ;REQUEUE AND DISMISS CLOCK LEVEL.
LOCK3B: MOVEI J,(TAC1) ;GET JOB NUMBER OF THE GUY WE'RE FORCING
MOVE TAC,JBTSTS(J)
TLNE TAC,SHF!SWP ;SKIP IF HE'S NOT IN MOTION ALREADY
JRST LOCKPL ;WE'LL HAVE TO WAIT FOR HIM TO STOP MOVING
HLRZ TAC,JBTPAG(J)
SKIPN XJOB(J) ;IS HE ALREADY EXPANDING?
PUSHJ P,XPAND ;NO. LET'S GIVE HIM A SHOVE
LOCKPL: MOVE TAC,[LOCK3A,,1] ;PLANT A CLOCK REQUEST.
CONO PI,PIOFF
IDPB TAC,CLOCK
CONO PI,PION
POPJ P,
LOCK3C: SETZM LOCKNO
POPJ P,
;LTHMOV, HTLMOV
IFN FTHPSG,<
↑LTHUUO:LDB J,PSEGN
JUMPE J,CPOPJ
JUMPL TAC,UUOERR
CAILE TAC,1
JRST UUOERR
JUMPG TAC,HTLMOV
PUSHJ P,MAPSET ;SETUP MAP TO MAKE UPPER LOOK LIKE MAIN JOB
;LOW TO HIGH MOVE. CALL WITH J=JOB TO MOVE. ASSUMES MAP IS SETUP FOR J AS JOB.
↑LTHMOV:SKIPN AC3,JBTMAP(J) ;SKIP IF A MAP EXISTS.
POPJ P,
LSH AC3,=9
HRLI AC3,-1000 ;AOBJN POINTER TO USER'S MAP.
MOVEI AC2,0 ;COUNT USER'S PAGES THAT GO TO HI CORE
LTHM1: SKIPN TAC1,(AC3) ;IS THERE A PAGE HERE?
JRST LTHM1B ;NO.
HRRZ TAC1,TAC1
CAIGE TAC1,1000 ;SKIP IF PAGE ALREADY LIVES IN HI CORE
ADDI AC2,1 ;COUNT A PAGE THAT WE MUST MOVE
LTHM1B: AOBJN AC3,LTHM1
JUMPE AC2,CPOPJ1 ;WIN IF ALL HIS PAGES ARE HI, OR NO PAGES.
CAMLE AC2,CORHTL ;WILL THIS FIT IN HI CORE?
POPJ P, ;NO. SORRY CHARLIE.
MOVE AC3,JBTMAP(J)
LSH AC3,=9
HRLI AC3,-1000
MOVE LOC,FHUPAG ;SEARCH FOR FREE PAGES IN HI CORE.
LTHM2: SKIPN TAC1,(AC3) ;IS THIS OLD PAGE IN LOW CORE?
JRST LTHM2Z ;NO SUCH PAGE.
HRRZ TAC1,TAC1
CAIL TAC1,1000
JRST LTHM2Z ;THIS PAGE IS IN HI CORE ALREADY
CAIA
LTHM2A: ADDI LOC,1
CAML LOC,LHUPAG ;HAS LOC RUN AMOK?
JRST 4,. ;YES. LOSE.
LDB TAC1,COREP ;GET A CORTAB BYTE
JUMPN TAC1,LTHM2A ;JUMP IF CLAIMED.
DPB J,COREP ;CLAIM THIS BLOCK FOR US.
SOS CORHTL ;COUNT IT AS IN USE.
MOVEI TAC1,SHFEXP ;CREATE AN EXEC PAGE POINTING TO THE
MOVEI TAC,(LOC) ;DESTINATION PAGE
PUSHJ P,ADDEMP ;DESTINATION PAGE IS MAPPED ONTO SHFEXP
NOKL10,< CONO PAG,1 >;NOKL10
IFKL10,< CONO KLPAG,660000+KLEPT⊗-=9 >;IFKL10
HLLZ TAC,AC3
ADD TAC,[1000,,SHFEXP] ;TAC←USER PAGE NUMBER,,EXEC PAGE NUMBER
LSH TAC,=9 ;TAC←USER ADDRESS,,EXEC ADDRESS
XCTR XBLTR,[BLT TAC,SHFEXP⊗9+777]
SETZM EXPGT+SHFEXP ;DELETE MAP ENTRY FOR DESTINATION
HRRZ TAC,(AC3) ;TAC←PAGE NUMBER OF OLD PAGE FOR USER
PUSHJ P,CORGB1
MOVEI TAC1,0
DPB TAC1,TAC ;FREE CORE.
AOS CORTAL ;AND COUNT THE LOW-CORE FREE COUNT
HRRM LOC,(AC3) ;STORE NEW MAP ENTRY FOR THIS USER.
SOJLE AC2,LTHM3 ;COUNT A PAGE MOVED. JUMP IF DONE
LTHM2Z: AOBJN AC3,LTHM2 ;LOOP MOVING PAGES
LTHM3: MOVE AC3,JBTMAP(J)
LSH AC3,=9
HRRZ TAC,(AC3) ;GET PAGE NUMBER OF VIRTUAL PAGE 0
HRRM TAC,JBTPAG(J) ;STORE AS USER'S FIRST PAGE.
NOKL10,< CONO PAG,3 >;NOKL10
IFKL10,< CONO KLPAG,660000+KLEPT⊗-=9 >;IFKL10
PUSHJ P,HCBUG ;GOD BLESS US, EVERY ONE.
MOVE AC3,JBTSTS(J)
TLNE AC3,JSEG ;SKIP UNLESS THIS IS A SEGMENT
PUSHJ P,AUPMAP ;FOR SEGMENT, SPREAD NEW MAP TO ALL LOWERS
JRST DIDLE9 ;RECOMPUTE SWAPPING PARAMS. SKIP
;HIGH TO LOW MOVE. CALL AT UUO LEVEL WITH J=JOB NUMBER TO MOVE.
↑HTLMOV:HRRZ TAC,JBTPAG(J)
CAIGE TAC,1000 ;IS THIS JOB IN HIGH CORE?
POPJ P, ;NO. THAT WAS EASY
JRST HTLMV2
HTLMV1: PUSHJ P,WSCHED ;WAIT FOR IO TO STOP
HTLMV2: PUSHJ P,ANYACT
JRST HTLMV1 ;IO STILL ACTIVE
HLRZ TAC,JBTPAG(J)
DPB TAC,IMGIN
DPB TAC,IMGOUT
MOVSI TAC,SWP
IORM TAC,JBTSTS(J) ;MARK THE JOB AS HAVING BEEN SWAPPED OUT
JRST WSCHED ;EXIT TO WSCHED VIA MAPSET
;ENTER HERE FROM SWAPPER WHEN THERE'S LOW CORE AVAILABLE.
;J=JOB NUMBER. TAC=DESIRED CORE SIZE (IN PAGES).
↑HTLFIN:PUSHJ P,HOLSRC ;LOOK FOR A HOLE IN LOWCORE
POPJ P, ;LOSE. NONE EXISTS.
;LOC=NEW LOCATION. TAC=NEW SIZE.
PUSHJ P,APRMAP ;SETUP MAP (SWAPPER PUSHED MAP)
MOVSI PROG,(TAC)
HRRI PROG,(LOC) ;SETUP PROG FOR CALL TO DIDDLE
MOVE AC3,JBTMAP(J)
LSH AC3,=9
HRLI AC3,-1000
PUSH P,TAC ;COUNT OF PAGES TO MOVE
HTLFN1: SKIPN TAC,(AC3) ;IS THERE A HIGH PAGE HERE?
JRST HTLFN2 ;NO PAGE AT ALL
HRRZ TAC,TAC
CAIGE TAC,1000
JRST HTLFN2 ;THIS PAGE IS ALREADY LOW.
PUSHJ P,CORGB1
LDB TAC1,TAC
CAIE TAC1,(J)
HALT .+1
MOVEI TAC1,0
DPB TAC1,TAC ;FREE HIGH CORE BYTE
AOS CORHTL ;FREE HIGH CORE BYTE
MOVEI TAC,(LOC)
PUSHJ P,CORGB1
LDB TAC1,TAC
JUMPE TAC1,.+2
HALT .+1
DPB J,TAC ;CLAIM LOWCORE BYTE
SOS CORTAL
MOVEI TAC1,SHFEXP
MOVEI TAC,(LOC)
PUSHJ P,ADDEMP
NOKL10,< CONO PAG,1 >;NOKL10
IFKL10,< CONO KLPAG,660000+KLEPT⊗-=9 >;IFKL10
HLLZ TAC,AC3
ADD TAC,[1000,,SHFEXP]
LSH TAC,=9 ;USER'S ADDRESS,,EXEC PAGE ADDRESS
XCTR XBLTR,[BLT TAC,SHFEXP⊗9+777]
SETZM EXPGT+SHFEXP
HRRM LOC,(AC3) ;UPDATE USER'S MAP
ADDI LOC,1
SOSG (P)
JRST HTLFN3 ;LEAVE IF COUNT IS EXHAUSTED
HTLFN2: AOBJN AC3,HTLFN1
HTLFN3: SUB P,[1,,1]
NOKL10,< CONO PAG,1
CONO PAG,3 >;NOKL10
IFKL10,< CONO KLPAG,660000+KLEPT⊗-=9 >;IFKL10
PUSHJ P,HCBUG
MOVEI LOC,(PROG) ;SETUP FOR DIDLE
MOVEI BLK,0
JRST DIDLE
HCBUG: PUSH P,J
PUSH P,LOC
PUSH P,AC2
PUSH P,TAC
MOVEI J,JOBN-1
HCB1: SKIPN AC2,JBTPAG(J)
JRST HCB2
MOVEI LOC,(AC2)
CAIGE LOC,1000
JRST HCB2
MOVE AC2,JBTMAP(J)
LSH AC2,=9
HRLI AC2,-1000
HCB1A: SKIPN LOC,(AC2)
JRST HCB1B
LDB TAC,COREP
CAIN TAC,(J)
JRST HCB1B
PUSHACS
PUSHJ P,DISJOB
PUSHJ P,DISMES
ASCIZ / JBTMAP - CORTAB INCONSISTENT. FIX IT OR RELOAD.
/
PUSHJ P,DISFLU
POPACS
PUSHJ P,DDTCALL
HCB1B: AOBJN AC2,HCB1A
HCB2: SOJG J,HCB1
POP P,TAC
POP P,AC2
POP P,LOC
POP P,J
POPJ P,
>;IFN FTHPSG
SUBTTL FREE STORAGE ;AND OTHER POLITICAL PRISONERS
; "AND WHO DESERVES THE CREDIT? AND WHO DESERVES THE BLAME?
; NIKCOLI IVANOVITCH LOBACHEVSKY IS HIS NAME."
; JAM - ORIGINAL FREE STORAGE SYSTEM
; REG - REVISED SYSTEM MARCH 1972
; ACCUMULATOR DEFINITIONS
SIZE←AC3 ;INPUT PARAMETER TO FSGET
BLOCK←AC1 ;BLOCK ADDRESS OF FS BLOCK (BLK)
PICMSK←←37 ;MASK TO SELECT CHANNELS 3,4,5,6,7 IN CONO/I PI
PICHON←←2000 ;BIT TO TURN ON SELECTED CHANNELS: CONO PI
PICHOF←←1000 ;BIT TO TURN OFF SELECTED CHANNELS
;THE FREE STORAGE SYSTEM ASSUMES THAT CHANNELS 1 AND 2 NEVER REQUEST
;FREE STORAGE.
;INITIALIZE FREE STORAGE - FSINIT
COMMENT $
MEMSIZ: <LOWEST WORD OF FREE STORAGE AREA>
RMEMSIZ: <LOWEST NON-EX ADDRESS IN ALL CORE>
FREE STORAGE LOOKS LIKE:
BLOCK IN USE: BLOCK THAT IS FREE
(LOW ADDRESS)
--------------- ---------------
| RS1 | *---|→→→* | U | *---|→→→*
--------------- ↓ --------------- ↓
| | ↓ | | ↓
| | ↓ | | ↓
| | ↓ | | ↓
| DATA AREA | ↓ | | ↓
| | ↓ --------------- ↓
| | ↓ | 0 | BLINK| ↓
--------------- ↓ --------------- ↓
|⊗ SIZE| RS2 |←←←* | SIZE | FLINK|←←←*
--------------- ---------------
(HIGH ADDRESS)
WHERE SIZE IS THE TOTAL SIZE OF THE BLOCK IN WORDS.
THE DATA AREA HAS SIZE-2 WORDS. ⊗SIZE IS SIZE + 400000.
RS1 = reserved for free storage system future use. Presently -1
RS2 = reserved for free storage system future use. Presently 0
U IS UNDEFINED.
FLINK IS A FORWARD LINK IN A CHAIN OF FREE BLOCKS.
LINKS WILL EVENTUALLY POINT BACK TO THE BASE OF THE CHAIN!
BLINK IS A BACKWARD LINK IN A CHAIN OF FREE BLOCKS.
THERE ARE "NFSB" CHAINS OF FREE BLOCK WITH FORWARD AND
BACKWARD POINTERS IN FSAVB TABLE.
ALL FREE STORAGE BLOCKS ARE SOME MULTIPLE OF THE "TRIVIAL" SIZE.
ALL REQUESTS ARE ROUNDED UP TO SUCH A MULTIPLE.
CHAINS OF FREE BLOCKS OF EACH SIZE ARE KEPT WITH BASE POINTERS IN FSAVB.
$
↑FSINIT:
SETZM LOCKNO ;NO JOB IS ATTEMPTING TO LOCK
MOVE TAC,SYSTOP
MOVEM TAC,LOKTOP ;TOP OF LOCKED CORE IS SAME AS SYSTEM TOP.
LSH TAC,-=9
MOVEM TAC,LOKPAG ;FIRST UNLOCKED PAGE
SETZM FSBEG
MOVE TAC,[XWD FSBEG,FSBEG+1]
BLT TAC,FSEND
SYNINI FSCSC ;INITIALIZE INTERLOCK CELL
IFE FTEXPG,< ;(IN FTEXPG, WE ALWAYS START FRESH)
.FATAL this code hasn't been fixed!
MOVE LOC,MEMSIZ ;GET THE SIZE OF USER SPACE
CAMN LOC,RMEMSIZ ;SKIP IF WE HAVE SOME STORAGE CLAIMED
JRST FSINI2 ;NO. WE HAVE NOTHING TO GIVE BACK
PUSHJ P,CORGBP ;GET A POINTER TO OUR LOWEST BLOCK
MOVEM TAC,CORLST ;SAVE AS POINTER TO THE END OF ALL CORE
MOVEI AC2,2000
FSINI1: IDPB AC2,CORLST ;CLEAR BLOCKS IN CORTAB
ADDI LOC,1000 ;ADD TO BOTTOM OF FS.
AOS CORTAL ;INCREMENT CORE COUNT
ADDM AC2,CORMAX ;INCREASE USER CORE
CAME LOC,RMEMSIZ ;AT THE TOP YET?
JRST FSINI1 ;NO LOOP
IBP CORLST ;POINTS TO FIRST CORTAB BYTE THAT IS NXM
>;IFE FTEXPG
IFN FTEXPG,< MOVE LOC,RMEMSIZ >
FSINI2: MOVEM LOC,MEMSIZ ;SAVE RMEMSIZ AS MEMSIZ
MOVNI UCHN,FSNINIT*2 ;NUMBER OF PAGES TO CLAIM NOW
ADDM UCHN,CORTAL ;DECREASE USER'S SPACE
MOVNI LOC,2000*FSNINIT ;GET - NUMBER OF WORDS CLAIMED
ADDM LOC,CORMAX ;DECREASE USER SPACE
ADDB LOC,MEMSIZ ;SET LOWER BOUND OF FS
LSH LOC,-=9
MOVEM LOC,MEMPAG ;PAGE NUMBER CORRESPONDING TO MEMSIZ
MOVEI UCHN,FSNINIT*2
FSINI3: PUSHJ P,CORGBP
MOVEI TAC1,105
DPB TAC1,TAC ;CLAIM BLOCK FROM CORTAB
IFN FTEXPG,< MOVEI TAC1,(LOC) ;ADD THIS PHYSICAL PAGE
PUSHJ P,ADDEVP ;TO THE EXEC MAP >;IFN FTEXPG
ADDI LOC,1
SOJG UCHN,FSINI3
MOVE UCHN,[XWD 2000*FSNINIT,FSAVB+2*NFSB-1] ;SIZE,,FLINK
MOVE AC2,RMEMSIZ ;FIRST NONEX ADDRESS
SUBI AC2,1 ;ADDRESS OF HI END OF FIRST BLOCK
MOVEM UCHN,(AC2) ;SET SIZE,,FLINK IN TOP OF BLOCK
HRRZM UCHN,-1(AC2) ;SET BLINK
MOVEM AC2,@MEMSIZ ;ADDRESS OF TOP GOES INTO BOTTOM
SETZ UCHN,
FSINI5: MOVEI AC3,FSAVB+1(UCHN) ;GET ADDRESS OF SOMEONE
MOVEM AC3,FSAVB(UCHN) ;SAVE BACK POINTER
MOVEM AC3,FSAVB+1(UCHN) ;SAVE FORWARD POINTER
ADDI UCHN,2 ;INCREMENT BY 2
CAIGE UCHN,2*NFSB-2 ;ARE WE AT THE END YET?
JRST FSINI5 ;NO KEEP LOOPING
HRRZM AC2,FSAVB+2*NFSB-2 ;SAVE BACK POINTER TO ONLY BLOCK
HRRZM AC2,FSAVB+2*NFSB-1 ;SAVE FORWARD POINTER TO ONLY BLOCK
MOVEI AC2,JIFSEC*=60 ;NUMBER OF TICKS BETWEEN CHECKER CHECK
MOVEM AC2,FSCKCT ;SAVE
MOVEI UCHN,FSLIST ;GET THE START OF OUR Q SPACE
MOVEM UCHN,FSIPTR ;SAVE AS Q INPUT POINTER
MOVEM UCHN,FSOPTR ;AND Q OUTPUT POINTER
JRST SFSINI ;INITIALIZE FREE STORAGE SPARE LIST USERS
LOSYS
FSACSV: EXCH DAT,(P) ;PUSHJ P,FSACSV TO SAVE AC'S.
PUSH P,TAC
PUSH P,TAC1
PUSH P,AC2
PUSH P,SIZE
PUSH P,TEM
JRST (DAT)
FSACRS: POP P,TEM ;JSP DAT,FSACRS TO RESTORE AC'S
POP P,SIZE
POP P,AC2
POP P,TAC1
POP P,TAC
EXCH DAT,(P)
POPJ P,
COMMENT $ FSGET: GET FREE STORAGE AT ANY LEVEL.
CALLING:
MOVEI SIZE,<BLOCK SIZE> ;SIZE≡AC3
PUSHJ P,FSGET
<NONE AVAILABLE>
<OK - ADDRESS OF BLOCK IS IN BLOCK (AC1)>
UUO LEVEL ALWAYS GETS SUCCESS EXIT
ALTERNATE CALLS:
FSGETU ;ENTER HERE AT UUO LEVEL.
;GIVE ERROR RETURN INSTEAD OF WAITING
FSGETP ;ENTER HERE GETS 1K BLOCK ALIGNED ON A 1K ADDRESS.
;INITIAL CONTENTS OF SIZE ARE IGNORED.
$
FSSBYP: POINT 17,(BLOCK),17 ;POINTER TO SIZE FIELD OF BLOCK
FSSBP1: POINT 17,(AC2),17 ;POINTER TO SIZE WHEN BLOCK TOP IN AC2
FSGETP: MOVEI BLOCK,1 ;HERE TO GET 1K ON A 1K BOUNDARY.
JRST FSGETV ;SIZE SETUP AS 1776
↑FSGET: TDZA BLOCK,BLOCK ;NORMAL CALL.
↑FSGETU:MOVNI BLOCK,1 ;CALL AT UUO LEVEL AND NEVER WAIT.
FSGETV: CONSZ PI,60000 ;ARE WE TBELOW CHANNEL 2?
JRST FSGLUZ ;NO. SOMEONE SHOULD KNOW BETTER.
CONSO PI,77400 ;ANY PI'S IN PROGRESS?
SKIPE INTACT(PID) ;WE'RE AT UUO LEVEL? USER INTERRUPT?
JRST .+2 ;EITHER PI IN PROGRESS OR USER I-LEVEL
MOVEM BLOCK,FSGTUF ;NORMAL UUO LEVEL. SET SPECIAL FLAG.
; NEGATIVE MEANS DON'T WAIT TO GET FS.
AOS NFSGETS ;COUNT FS GETS
PUSHJ P,FSACSV ;SAVE DAT,TEM,SIZE,AC2,TAC,TAC1
PSYNC FSCSC ;SYNCHRONIZE WITH OTHER PROCESSOR
MOVEI SIZE,2(SIZE) ;GET SIZE OF REQUEST +2
TRZE SIZE,TRIVIAL-1 ;IS THIS EXACT MULTIPLE OF TRIVIAL?
ADDI SIZE,TRIVIAL ;NO. ADD TRIVIAL
FSGETT: JUMPG BLOCK,FSGPAG ;JUMP IF SPECIAL CALL TO GET 1K
MOVEI TAC,(SIZE) ;GET SIZE INTO TAC
LSH TAC,1-TSHF ;SHIFT TO MAKE INDEX
SUBI TAC,2 ;NORMALIZE TO ZERO INDEX
CAILE TAC,2*NFSB-2 ;ARE WE AT THE END OF THE TABLE?
JRST FSGTBX ;YES. LOOK FOR A BIG BLOCK
LSH TAC,-1
AOS FSRPQ(TAC)
LSH TAC,1
FSGT0: MOVE TAC1,TAC ;INDEX TO FIRST BASE INSPECTED
MOVE BLOCK,MEMSIZ ;FIND BLOCK WITH A HIGHER ADDRESS
FSGT1: CAMGE BLOCK,FSAVB+1(TAC1) ;ADDRESS BIGGER THAN OUR BEST?
MOVE BLOCK,FSAVB+1(TAC1) ;YES. REMEBER BEST ADDRESS
ADDI TAC1,2 ;GO ON TO NEXT LIST BASE
AOS NFSLP1 ;COUNT A LOOP OF TYPE1
CAIGE TAC1,2*NFSB ;STILL IN TABLE?
JRST FSGT1 ;YES. LOOP
CAMG BLOCK,MEMSIZ ;FOUND ANY?
JRST FSGTW ;NO WE'LL HAVE TO WAIT...
PUSHJ P,FSGCL ;CALL ROUTINE TO CLAIM AND DELINK
JRST FSGT0 ;THE CLAIM FAILED. LOOK AGAIN.
JRST FSGTC ;CLAIM OK
;CLAIM AND DELINK THE FS BLOCK POINTED TO BY (BLOCK).
;SKIP ON SUCCESS (LEAVES TAC1 AND TAC SETUP AS PARAMETERS FOR FSGTC5)
FSGCL: CONI PI,AC2 ;GET PI CHANNEL STATUS
ANDI AC2,PICMSK ;ONLY CHANNELS 3,4,5,6,7
CONO PI,PICHOF(AC2) ;TURN OFF CHANNELS 3-7
SKIPG TAC1,(BLOCK) ;FLINK INTO TAC1
JRST FSGCLX ;BLOCK IS ALREADY CLAIMED!
HRRZ TAC,-1(BLOCK) ;BLINK INTO TAC
HRRM TAC1,(TAC) ;GO BACK AND RESET FLINK
HRRM TAC,-1(TAC1) ;GO FORWARD AND RESET BLINK
CONO PI,PICHON(AC2) ;RESTORE CHANNELS THAT WERE ON
MOVSI AC2,400000
IORM AC2,(BLOCK) ;TURN ON THE SIGN BIT TO CLAIM BLOCK
JRST CPOPJ1 ;GIVE THE SKIP RETURN
FSGCLX: CONO PI,PICHON(AC2) ;RESTORE PI.
POPJ P,
;HERE TO GET A BIG FS BLOCK
FSGTBX: AOS FSRPQ+NFSB-1
FSGTB0: HRRZ BLOCK,FSAVB+2*NFSB-1 ;GET THE FIRST LINK
FSGTB1: AOS NFSLP2 ;COUNT A LOOP OF TYPE 2
CAIG BLOCK,FSAVB+2*NFSB-1 ;FLINK > ADDRESS OF LIST BASE?
JRST FSGTW ;NO. WE'LL HAVE TO WAIT.
SKIPG AC2,(BLOCK) ;SKIP IF THIS BLOCK IS NOT CLAIMED
JRST FSGTB0 ;HIGHER CHANNEL MUST HAVE GOT THIS ONE!
HLRZ TAC1,AC2 ;GET THE SIZE FIELD
CAIL TAC1,(SIZE) ;SIZE BIG ENOUGH?
JRST FSGTB2 ;YES. TRY TO CLAIM IT
MOVEI BLOCK,(AC2) ;LOAD NEXT FLINK
JRST FSGTB1 ;LOOP
FSGTB2: PUSHJ P,FSGCL ;CLAIM THE BLOCK AND DELINK IT
JRST FSGTB0 ;CLAIM FAILED.
JRST FSGTC ;GOT IT
FSGPAG: HRRZ BLOCK,FSAVB+2*NFSB-1 ;GET THE FIRST LINK
MOVEI SIZE,1000 ;1 PAGE NEEDED
FSGPG1: AOS NFSLP2 ;COUNT A LOOP OF TYPE 2
CAIG BLOCK,FSAVB+2*NFSB-1 ;FLINK > ADDRESS OF LIST BASE?
JRST FSGTWX ;NO. WE'LL HAVE TO WAIT.
SKIPG AC2,(BLOCK) ;SKIP IF THIS BLOCK IS NOT CLAIMED
JRST FSGPAG ;HIGHER CHANNEL MUST HAVE GOT THIS ONE!
HLRZ TAC1,AC2 ;GET THE SIZE FIELD
CAIL TAC1,(SIZE) ;SIZE BIG ENOUGH?
JRST FSGPG3 ;YES. SEE IF IT IS REALLY BIG ENOUGH.
FSGPG2: MOVEI BLOCK,(AC2) ;LOAD NEXT FLINK
JRST FSGPG1 ;LOOP
FSGPG3: MOVN TAC1,TAC1 ;-SIZE OF BLOCK
ADDI TAC1,1
ADDI TAC1,(BLOCK) ;ADDRESS OF BLOCK BOTTOM.
TRNE TAC1,777 ;IS LOW ADDRESS ALREADY ON A PAGE BOUNDARY?
ADDI TAC1,1000 ;NO. INCREASE TO LOWEST PAGE BOUND IN BLOCK
TRZ TAC1,777 ;TAC1←LOWEST PAGE BOUNDARY ADDRESS IN BLOCK
MOVEI TAC,(BLOCK)
ADDI TAC,1 ;ADDRESS OF NEXT HIGHER BLOCK
TRZ TAC,777 ;TAC←HIGHEST PAGE BOUNDARY ADDRESS IN BLOCK
SUBI TAC,1000 ;SEE IF THERE'S ANY SPACE THERE TO TAKE PAGE
CAMGE TAC,TAC1 ;IF HIGH-PAGE IS AT LEAST AS BIG AS LOW
JRST FSGPG2 ;LOSE. ADVANCE TO NEXT FS BLOCK
PUSHJ P,FSGCL ;CLAIM THE BLOCK AND DELINK IT
JRST FSGPAG ;CLAIM FAILED.
;DON'T CLOBBER TAC AND TAC1 - NEEDED BY FSGTC5
MOVEI AC2,(BLOCK)
ADDI AC2,1 ;ADDRESS OF NEXT HIGHER BLOCK
TRZ AC2,777 ;AC2←HIGHEST PAGE BOUNDARY ADDRESS IN BLOCK
SUBI AC2,1 ;THIS IS DESIRED BLOCK TOP.
CAIL AC2,(BLOCK) ;DIFFERENT FROM BLOCK?
JRST FSGTC ;NO. RETURN 1K PIECE OF BLOCK
;RANGE (AC2)+1 TO (BLOCK) IS DISCARDED. AC2 (ENDS IN 777) IS IMPORTANT PART.
PUSH P,AC2 ;ADDRESS OF IMPORTANT PART (ENDS IN 1777)
HRROM BLOCK,1(AC2) ;MAKE DISCARD BLOCK. LOWER BLK POINTER
LDB DAT,FSSBYP ;SIZE OF BIG BLOCK
MOVEI TEM,(BLOCK) ;HIGHEST ADDRESS IN BIG BLOCK.
SUBI TEM,(AC2) ;TEM←SIZE OF DISCARD BLOCK
SUBI DAT,(TEM) ;DAT←SIZE OF IMPORTANT PIECE
IORI DAT,400000
HRLZM DAT,(AC2) ;STUFF SIZE OF IMPORTANT PIECE IN TOP.
TRZ DAT,400000 ;CLEAR CLAIM BIT.
SUBM AC2,DAT ;LOW ADDR OF IMPORTANT PIECE
HRRZM AC2,1(DAT) ;NEW LOWER BLK POINTER. (LOOKS FREE)
IORI TEM,400000 ;SIZE OF DISCARD - SET CLAIM
HRLZM TEM,(BLOCK) ;DISCARD BLOCK NOW LOOKS CLAIMED.
MOVEI BLOCK,2(AC2) ;GIVE BACK DISCARD BLOCK.
PUSHJ P,FSQUIK ;RETURN DISCARD AS WE LEAVE VIA FSGRT1
POP P,BLOCK ;ADDRESS OF IMPORTANT PART.
;FALL INTO FSGTC
;FSGTC - TRIM THE BLOCK WE CLAIMED TO THE SIZE WE REQUESTED. IF THE
;REMAINDER EXCEEDS 170 WORDS THEN WE USE TAC AND TAC1 (AS SETUP BY
;FSGCL) TO HELP RETURN THE REMAINDER NOW. IF THE REMAINDER IS SMALL,
;IT IS PLACED ON THE RETURN LIST, WHERE IT WILL BE RETURNED NEXT CLOCK
;TICK, OR, IF WE'RE AT CH7 OR UUO LEVEL IT'S RETURNED AS WE EXIT VIA FSGRT1
FSGTC: LDB AC2,FSSBYP ;GET THE SIZE OF THIS BLOCK
SETZ TEM, ;INITIALIZE EXCESS SIZE
CAIGE AC2,TRIVIAL(SIZE) ;IS BLOCK TOO BIG?
JRST FSGTC1 ;NO
MOVE TEM,AC2 ;GET THE SIZE
SUBI TEM,(SIZE) ;GET EXCESS SIZE
MOVEI AC2,(SIZE) ;GET THE SIZE TO USE
DPB AC2,FSSBYP ;SET SIZE
FSGTC1: HLLZS (BLOCK) ;CLEAR RIGHT SIDE OF TOP MARK
SUBM BLOCK,AC2 ;AC2 GETS ADDRESS BELOW LOWEST
HRROM BLOCK,1(AC2) ;SET UP POINTER IN THE LOW ADDRESS
JUMPE TEM,FSGTCR ;ALL DONE IF NO SPLIT
HRLZM TEM,(AC2) ;SET SIZE IN SPLIT BLOCK
SUBM AC2,TEM ;GET LOWEST ADDRESS OF THIS, -1
HRRZM AC2,1(TEM) ;SET UP FORWARD LINK
HLRZ TEM,(AC2) ;GET THE SIZE BACK
CAIGE TEM,NFSB*TRIVIAL ;IS BLOCK VERY BIG?
JRST FSGTC4 ;NO. RETURN THE SPLIT BY THE CLOCK
JRST FSGTC5 ;TAC AND TAC1 WERE SETUP BY FSGCL
;HERE WE TRY TO RELINK THE REMAINDER INTO THE FREE LIST,
;IF THIS FAILS, WE RETURN THE REMAINDER VIA THE RETURN-LIST MECHANISM
FSGTC2: CONO PI,PICHON(TEM) ;TURN CHANNELS ON AGAIN
FSGTC5: SKIPG (TAC1) ;LOOK AHEAD
JRST FSGTC6 ;LOSE
MOVE DAT,-1(TAC1) ;GET BLINK AHEAD
HRRM DAT,-1(AC2) ;SET BLINK HERE
HRRM TAC1,(AC2) ;SET FLINK HERE
CONI PI,TEM ;GET PI STATUS
ANDI TEM,PICMSK
CONO PI,PICHOF(TEM) ;TURN OFF CHANNELS
SKIPLE (TAC1) ;GRABBED FROM UNDER US?
CAME DAT,-1(TAC1) ;BE SURE
JRST FSGTC2 ;TRY AGAIN
HRRM AC2,-1(TAC1) ;SET BLINK AHEAD
HRRM AC2,(DAT) ;SET FLINK BEHIND
CONO PI,PICHON(TEM) ;TURN ON PI'S AGAIN
JRST FSGTCR ;RETURN FREE STORAGE.
FSGTC3: CONO PI,PICHON(TEM)
FSGTC6: SKIPG DAT,(TAC)
JRST FSGTC4 ;LINK'S HAVE MOVED
HRRM DAT,(AC2) ;SET FLINK HERE
HRRM TAC,-1(AC2) ;SET BLINK HERE
CONI PI,TEM
ANDI TEM,PICMSK
CONO PI,PICHOF(TEM)
CAME DAT,(TAC) ;THESE GUYS STILL THE SAME?
JRST FSGTC3 ;LINKS HAVE MOVED. TRY AGAIN
HRRM AC2,-1(DAT) ;SET BLINK AHEAD
HRRM AC2,(TAC) ;SET FLINK BEHIND
CONO PI,PICHON(TEM)
JRST FSGTCR ;RETURN BLOCK
FSGTC4: MOVSI TAC,400000
IORM TAC,(AC2)
LDB TAC,FSSBP1
SUBM AC2,TAC
HRROM AC2,1(TAC)
PUSH P,BLOCK
MOVEI BLOCK,2(TAC)
PUSHJ P,FSQUIK ;ADD BLOCK TO FSRTL.
POP P,BLOCK
FSGTCR: LDB TAC,FSSBYP ;GET THE SIZE
ADDM TAC,FSBUSY ;ADD TO CLAIMED AMOUNT.
SUBI BLOCK,-2(TAC) ;COMPUTE LOWEST USABLE ADDRESS
CONSO PI,77000 ;SKIP IF AT HI PI CHANNEL
SKIPN FSRTL ;LOW CHANNEL. SKIP IF ANY COMING BACK
JRST FSGRT1 ;NOTHING TO DO OR MUST RETURN QUICK
PUSH P,BLOCK
PUSHJ P,FSCKX ;GIVE IT BACK TO THE INDIANS
POP P,BLOCK
FSGRT1: XSYNC FSCSC
JSP DAT,FSACRS
PUSH P,[FSGET] ;IN CASE OF TROUBLE TRY AGAIN
PUSHJ P,FSECHK ;INCASE OF ERROR, RETURN UPLEVEL.
POP P,(P) ;FLUSH STACK
JRST CPOPJ1 ;AND GIVE SKIP RETURN
;HERE IF WE COULDN'T FIND ANY FREE STORAGE.
FSGTW: TDZA BLOCK,BLOCK ;NORMAL ENTRY
FSGTWX: MOVEI BLOCK,1 ;ENTRY FOR NEED 1K ON A 1K BOUNDARY
PUSHJ P,FSGETK ;WE NEED ANOTHER K, GET IT
JRST FSGTW5 ;CAN'T GET ANOTHER K
PUSHJ P,FSWAKE ;WAKE SOMEONE WHO WAITS
JRST FSGETT ;FSGET RETRY THIS ONE
FSGTW5: CONSO PI,77400 ;ARE WE AT I-LEVEL?
SKIPGE FSGTUF ;NOT I-LEVEL, WANT TO RETURN QUICK?
JRST FSGFAI ;GIVE THE NON-SKIP RETURN
SKIPE INTACT(PID) ;IF YOU'RE AT USER I-LEVEL YOU'LL
JRST WSCHED ;BE KICKED OUT BY WSCHED....
AOS NFSWAITS ;COUNT A WAIT
PUSH P,J ;SAVE J ON THE STACK
MOVE J,JOB(PID) ;GET THE JOB NUMBER
HRL J,SIZE ;GET THE SIZE OF REQUEST
MOVEM J,@FSIPTR ;SAVE IN OUR QUEUE OF JOBS
AOS TAC,FSIPTR ;INCREMENT THE POINTER
CAIL TAC,FSLIST+JOBN
MOVEI TAC,FSLIST
MOVEM TAC,FSIPTR
AOS FSCNT
XSYNC FSCSC
PUSHJ P,WSCHED ;CALL CH7 TO RESCHEDULE JOB(PID)
SETZM FSGTUF ;ZERO THIS CELL SO IF WE FAIL AGAIN, WE WAIT
PSYNC FSCSC ;HERE EVENTUALLY AFTER FSWAKE
PUSHJ P,FSWAKE ;WAKE SOMEONE ELSE
POP P,J ;RESTORE J, FINALLY.
JRST FSGETT ;PLAY IT AGAIN, SAM.
FSGFAI: XSYNC FSCSC
JSP DAT,FSACRS ;RESTORE AC'S
AOS NFSGFA ;COUNT A FAILURE
POPJ P, ;CRY
FSGLUZ: HRRZ BLOCK,(P) ;GET RETURN ADDRESS
PUSHACS
PUSHJ P,DISERR
[ASCIZ/ FSGET CALLED ILLEGALLY FROM PI CHANNEL 1 OR 2
RETURN ADDRESS = /]
DISARG ( LOC,<BLOCK-20(P)> )
[ASCIZ/
/]
-1
POPACS
JUMPE PID,CPOPJ
HALT CPOPJ ;STOP THE PDP-6
;SWIPE 1K FROM AVAILABLE USER SPACE.
;THIS CAN BE DONE ONLY AT CLOCK OR UUO LEVEL.
;IT SETS THE FOLLOWING GLOBAL VALUES:
; CORLST BYTE POINTER SET TO THE SECOND UNAVAILABLE 1K BLOCK.
; CORTAL NUMBER OF 1K BLOCKS AVAILABLE TO USERS
; CORMAX MAXIMUM NUMBER OF WORDS A JOB MAY HAVE.
; MEMSIZ LOWEST LOCATION USED BY FREE STORAGE
FSGETK: CONSO PI,77000 ;SKIP IF PI IN PROGRESS (EXCEPT CLKCHN)
JUMPE PID,FSGTKZ ;CH7 OR UUO LEVEL. JUMP IF P1 (TO HISYS)
POPJ P, ;CAN'T DO THIS ABOVE CH7 OR ON P2
HISYS
FSGTKZ: MOVE TAC,MEMPAG ;GET THE CURRENT MEMORY SIZE
SUBI TAC,1 ;GET LOWEST ADDRESS WE WANT
PUSHJ P,CORGB1 ;MAKE A BYTE POINTER TO CORTAB
LDB TAC1,TAC ;PICK UP MARK BIT FOR THIS BLOCK
JUMPN TAC1,FSSWAP ;JUMP IF CLAIMED AND FORCE USER OUT
MOVEI TAC1,105 ;CLAIM THIS BLOCK!
DPB TAC1,TAC ;STUFF OUR CLAIM BIT IN
MOVNI TAC,1000 ;UPDATE 4 GLOBAL CELLS
ADDM TAC,CORMAX ;MAXIMUM CORE SIZE IN WORDS
ADDM TAC,MEMSIZ ;BOTTOM OF FREE STORAGE
SOS TAC1,MEMPAG
SOS CORTAL ;NUMBER OF PAGES FOR USERS
IFN FTEXPG,< PUSHJ P,ADDEVP ;ADD PHYSICAL PAGE = VIRTUAL PAGE >;FTEXPG
IFKL10,< PUSHJ P,SWEEPA ;MAKE SURE CACHE DOESN'T GET ANY>
IFN FTCORBUG,< PUSHJ P,CORCHK > ;CHECK VALIDITY OF CORE TABLES.
PUSH P,LOC
PUSH P,UCHN
PUSH P,BLOCK
PUSH P,SIZE
PUSHJ P,DIDLE4 ;SET UP SWAPPER PARAMTERS
MOVE BLOCK,MEMSIZ ;GET THE LOW BOUND OF FS.
ADDI BLOCK,777 ;POINTER TO HIGH SIDE OF THIS PAGE
MOVSI TAC,401000 ;SET UP SIZE AND USE BIT
MOVEM TAC,(BLOCK) ;STUFF IN BLOCK HEADER
HRROM BLOCK,@MEMSIZ ;STUFF IN LOWER MARKER
MOVE BLOCK,MEMSIZ
ADDI BLOCK,1
PUSHJ P,FSGIVX ;GIVE BACK A 1K BLOCK (MERGES)
POP P,SIZE
POP P,BLOCK
POP P,UCHN
POP P,LOC
SETZM FSGVKF ;FLUSH WARNING ABOUT BOTTOM K.
JRST CPOPJ1 ;GIVE A SKIP RETURN FROM FSGETK
;ROUTINE TO FORCE THE JOB AT TOP OF CORE OUT.
FSSWAP: MOVE TAC,MEMPAG ;FIND OUT WHO'S AT THE TOP OF CORE
SUBI TAC,1 ;THIS IS THE ADDRESS OF SOME BLOCK
PUSHJ P,CORGB1
PUSH P,J ;DON'T CLOBBER J
LDB J,TAC ;GET JOB NUMBER OF THE GUY TO FORCE
MOVE TAC,JBTSTS(J)
TLNE TAC,SWP!SHF ;IS HE IN MOTION?
JRST FSWP3A ;CAN'T DO HIM NOW.
HLRZ TAC,JBTPAG(J)
SKIPN XJOB(J)
PUSHJ P,XPAND ;MAKE HIM GET SHOVED OUT
FSWP3A: POP P,J ;RESTORE J
FSSWP3: SETOM FSCLKF ;TELL FSCLK TO THINK ABOUT GOBBLING
SETOM FSNCLK ;TELL CLKSER TO RUN FSCLK
POPJ P, ;AND RETURN
; THIS ROUTINE REQUEUES A JOB WHEN CORE IS AVAILABLE FOR HIM.
FSWAKE: CONO PI,PIOFF
SKIPLE FSCNT ;ANYONE THERE?
JRST FSWAK1 ;YES
SETZM FSCNT
CONO PI,PION
POPJ P, ;NO WORK FOR NO ONE
FSWAK1: SOS FSCNT ;DECREASE NUMBER OF WAITERS
CONO PI,PION
HRRZ J,@FSOPTR ;GET JOB NUMBER TO REQUEUE
AOS TAC,FSOPTR
CAIL TAC,FSLIST+JOBN
MOVEI TAC,FSLIST
MOVEM TAC,FSOPTR
SKIPL JBTSTS(J) ;IS THIS GUY STILL RUNABLE?
JRST FSWAKE ;NO. TRY ANOTHER ONE.
MOVNI TAC,RUNQ
MOVEM TAC,JOBQUE(J) ;SET QUEUE FOR THIS JOB
JRST REQUE ;REQUEUE THIS JOB
;FSCLK: CLOCK LEVEL (CHANNEL 7) ROUTINES TO KEEP FREE STORAGE HAPPY!
;CALLED FROM CLKSER, NEAR CALL ON DPYCLK
↑FSCLK: SETZM FSNCLK ;WE HAVE GOTTEN SERVICE. SHUT OFF FLAG.
PSYNC FSCSC ;SYNCRONIZE
PUSHJ P,FSCKX ;RETURN CONTENTS OF FSRTL.
FSCKY: SKIPN FSCLKF ;ARE WE WAITING FOR THE SWAPPER?
JRST FSCLK1 ;NO. SKIP THIS MESS
SETZM FSCLKF
PUSHJ P,FSGETK ;LOOK FOR THE 1K WE WANTED.
JRST FSCKZ ;THERE WASN'T ANY THERE FOR US
PUSHJ P,FSWAKE ;ATTEMPT TO WAKE A WAITER.
JRST FSCKZ ;AVOID ATTEMP TO GIVE BACK 1K
FSCLK1: SKIPN FSGVKF ;MAYBE THERE'S A 1K BLOCK TO GIVE BACK?
JRST FSCKZ ;NOPE.
MOVE TAC,MEMPAG
PUSHJ P,CORGB1 ;COMPUTE BYTE POINTER TO FIRST FS BLOCK
LDB TAC,TAC ;GET THE CORTAB ENTRY
CAIE TAC,105 ;IS IT A REGULAR FREE BLOCK?
JRST FSCKZ ;NO, CAN'T RETURN IT TO USERS
SETZM FSGVKF
HRRZ BLOCK,@MEMSIZ ;POINTER TO TOP OF BOTTOM BLOCK
LDB SIZE,FSSBYP ;GET THE SIZE FIELD
CAIGE SIZE,1000 ;SKIP IF BIG ENOUGH
JRST FSCKZ
PUSHJ P,FSGCL ;ATTEMPT TO CLAIM THIS BLOCK
JRST FSCKZ ;LOSE
LDB SIZE,FSSBYP ;GET THE SIZE
MOVEI TEM,(BLOCK) ;GET THE BLOCK ADDRESS
SUBI TEM,-1(SIZE) ;GET THE BOTTOM ADDRESS
HRROM BLOCK,(TEM) ;CLAIM THE BOTTOM
CAIL SIZE,1000 ;SKIP IF SMALLER THAN A BREADBOX
CAME TEM,MEMSIZ ;BIG ENOUGH. AT BOTTOM?
JRST FSGVK3 ;NO. GIVE IT ALL BACK.
SUBI SIZE,1000 ;FIGURE SIZE OF NEW BLOCK
JUMPE SIZE,FSGVK1 ;THERE'S NOTHING TO SPLIT
DPB SIZE,FSSBYP ;SET SIZE FIELD IN BLOCK
SUBM BLOCK,SIZE ;GET THE BOTTOM ADDRESS
HRROM BLOCK,1(SIZE) ;SET THE BOTTOM MARK
MOVEI BLOCK,2(SIZE) ;GET THE ADDRESS FOR FSGIVE
SETOM (SIZE) ;MAKE HI END OF K LOOK CLAIMED.
PUSHJ P,FSGIVX ;GIVE BACK THIS PART OF THE BLOCK
FSGVK1: MOVEI TAC,1000
ADDM TAC,MEMSIZ
ADDM TAC,CORMAX
AOS CORTAL
MOVE LOC,MEMPAG
AOS MEMPAG
IFN FTEXPG,< MOVEI TAC1,(LOC)
PUSHJ P,DELEMP ;DELETE PAGE FROM EXEC MAP >;IFN FTEXPG
PUSHJ P,CORGBP
MOVEI TAC1,0
DPB TAC1,TAC
IFN FTCORBUG,< PUSHJ P,CORCHK > ;MAKE SURE CORTAB AND CORTAL ARE CONSISTENT
PUSHJ P,DIDLE4
SETOM FSGVKF ;FLAG FOR NEXT TICK JUST IN CASE
JRST FSCKZ
FSGVK3: MOVEI BLOCK,1(TEM) ;GET THE BOTTOM DATA WORD ADDRESS
PUSHJ P,FSGIVX ;GIVE BACK THIS BLOCK!
FSCKZ: SKIPLE FSCKCT ;TIME TO DO CHECKERBOARD?
JRST FSCLK3 ;NO.
MOVE BLOCK,RMEMSIZ
SUB BLOCK,MEMSIZ
SUB BLOCK,FSBUSY
CAILE BLOCK,5000 ;SKIP IF LESS THAN 2.5 FREE
JRST FSCLK4 ;TOO MUCH IS FREE.
MOVEI BLOCK,=30*JIFSEC ;LOOK AGAIN IN 30 SECONDS.
MOVEM BLOCK,FSCKCT
FSCLK3: XSYNC FSCSC
POPJ P,
FSCLK4: XSYNC FSCSC
MOVEI BLOCK,=10*JIFSEC
MOVEM BLOCK,FSCKCT
JRST RELEX ;RELEASE SPARES.
LOSYS
FSCKX: SKIPN FSRTL ;ANY ONE ON THE RETURN LIST?
POPJ P, ;NO. RETURN
CONO PI,PIOFF ;DON'T INTERRUPT
HRRZ BLOCK,FSRTL ;GET THE FORWARD LINK
MOVE TAC,(BLOCK) ;GET THE NEXT FLINK
HRRZM TAC,FSRTL ;SAVE IT HERE
CONO PI,PION ;TURN ON THE PI'S
LDB TAC,FSSBYP ;GET THE SIZE FIELD
SUBI BLOCK,-2(TAC) ;GET THE ADDRESS OF LOWEST DATA WORD
PUSHJ P,FSGIVX ;ALL SET TO GIVE THE BLOCK BACK AGAIN
JRST FSCKX ;LOOK FOR MORE
;FSQUIK, FSGIVE - RETURN FREE STORAGE TO SYSTEM.
COMMENT $
CALLING:
MOVE BLOCK,<ADDRESS OF BLOCK>
PUSHJ P,FSGIVE
<RETURN HERE ALWAYS>
FSGIVX IS ROUTINE FOR FSGIVE THAT DOESN'T SAVE AC'S
USE THIS ONLY INSIDE OF FS ROUTINES!
$
FSECHK: PUSH P,BLOCK ;SAVE AC'S FOR A WHILE.
PUSH P,SIZE ;SAVE.
CAMGE BLOCK,RMEMSIZ
CAMG BLOCK,MEMSIZ
JRST FSECK0 ;OUT OF BOUNDS
SUBI BLOCK,1
TRNE BLOCK,TRIVIAL-1 ;ALL THESE BITS MUST BE OFF!
JRST FSECK1 ;BAD ALLIGNMENT
MOVE SIZE,(BLOCK) ;GET BOTTOM LINK
TLC SIZE,-1
TLNE SIZE,-1
JRST FSECK2 ;BOTTOM LINK LEFT HALF NOT -1
CAMGE SIZE,RMEMSIZ
CAMG SIZE,MEMSIZ
JRST FSECK3 ;BOTTOM LINK POINTS TO GARBAGE
CAIG SIZE,(BLOCK)
JRST FSECK4 ;BOTTOM LINK POINTS BELOW BOTTOM WORD.
TRC SIZE,TRIVIAL-1
TRCE SIZE,TRIVIAL-1
JRST FSECK5 ;BAD ALIGNMENT ON TOP BLOCK
HLRZ BLOCK,(SIZE) ;GET 400000+SIZE OF THIS BLOCK
SUBI SIZE,-400002(BLOCK) ;MAKE POINTER TO 1 ABOVE THE BOTTOM
CAME SIZE,-1(P) ;MAKE SURE THESE ARE THE SAME.
JRST FSECK6 ;ALLEDGED TOP DOESN'T POINT TO BOTTOM.
POP P,SIZE
POP P,BLOCK
POPJ P,
FSECK0: JSP BLOCK,FSECKX ;ERROR 0 - OUT OF BOUNDS
FSECK1: JSP BLOCK,FSECKX ;ERROR 1 - BAD ALIGNMENT
FSECK2: JSP BLOCK,FSECKX ;ERROR 2 - BOTTOM LINK LEFT HALF NOT -1
FSECK3: JSP BLOCK,FSECKX ;ERROR 3 - BOTTOM LINK POINTS OUTSIDE FS
FSECK4: JSP BLOCK,FSECKX ;ERROR 4 - BOTTOM LINK POINTS BELOW ITSELF
FSECK5: JSP BLOCK,FSECKX ;ERROR 5 - BOTTOM LINK MISALIGNED
FSECK6: JSP BLOCK,FSECKX ;ERROR 6 - TOP DOESN'T POINT TO BOTTOM.
FSECKX: SUBI BLOCK,FSECK0+1 ;NORMALIZE
HRRZ BLOCK,BLOCK
PUSHACS
PUSH P,BLOCK
PUSHJ P,DISMES
ASCIZ /RELEASE OF NON-EX FREE STORAGE BLOCK. BLOCK = /
MOVE TAC,-22(P) ;REACH BACK AND PULL UP STINKING MESS.
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ /
CALLERS ADDRESS = /
MOVE TAC,-24(P)
PUSHJ P,DISLOC
PUSHJ P,DISMES
ASCIZ /; ERROR CODE = /
POP P,BLOCK
PUSHJ P,DISLOC
PUSHJ P,DISCRLF
PUSHJ P,DISFLUSH ;MAKE SURE WE CAN SEE MESSAGE.
POPACS
PUSHJ P,WDDTCAL
POP P,SIZE
POP P,TAC
POP P,(P) ;THROW OUT RETURN FROM FSCHEK
POPJ P, ;RETURN TO BASTARD WHO CALLED ME.
↑FSGIVE:ANDI BLOCK,-1 ;FLUSH LEFT HALF
PUSHJ P,FSECHK ;CHECK FOR WINNING ADDRESSES
AOS NFSGIVES ;INCREMENT COUNT OF GIVES
PUSH P,BLOCK ;SAVE THIS FOR A WHILE.
HRRZ BLOCK,-1(BLOCK) ;GET THE TOP ADDRESS
LDB BLOCK,FSSBYP ;GET THE SIZE
MOVN BLOCK,BLOCK ;GET -SIZE
ADDM BLOCK,FSBUSY ;DECREASE BUSY COUNT
POP P,BLOCK ;RESTORE BLOCK.
CONSZ PI,77000 ;SKIP IF WE'RE NOT IN CHANNELS 1-6
JRST FSQUK1 ;DO THE QUICK STUFF!
PUSHJ P,FSACSV ;SAVE AC'S
PUSHJ P,FSGIVY ;NOW GO GIVE BACK FREE STORAGE
JSP DAT,FSACRS ;RESTORE AC'S
POPJ P, ;RETURN
FSGIVX: PUSHJ P,FSECHK ;CHECK FOR ERROR.
CONSZ PI,77000 ;SKIP IF AT LOW LEVEL
JRST FSQUK1 ;AT HI CHANNEL GIVE BACK QUICK
FSGIVY: PUSH P,BLOCK ;SAVE BLOCK
PSYNC FSCSC ;LOCK OUT OTHER PROCESSOR
MOVEI AC2,-2(BLOCK) ;AC2 ← HIGH ADDRESS OF LOWER BLOCK
HRRZ BLOCK,-1(BLOCK) ;BLOCK SET TO TOP WORD OF THIS BLOCK
LDB TAC,[POINT 9,AC2,26]
PUSHJ P,CORGB1 ;BYTE POINTER TO CORTAB
LDB TAC,TAC
CAIE TAC,105 ;SKIP IF BLOCK IS ABOVE AN FS AREA.
JRST FSGV1 ;NO. EITHER AT BOTTOM OF FS OR ABOVE PMAP
PUSH P,BLOCK ;SAVE BLOCK TOP!
MOVE BLOCK,AC2 ;GET THE ADDRESS OF LOWER
PUSHJ P,FSGCL ;ATTEMPT TO CLAIM LOWER
JRST FSGV0 ;POP BLOCK AND FORGET ABOUT LOW MERGE
LDB TEM,FSSBYP ;GET THE SIZE
MOVEI DAT,(BLOCK)
SUBI DAT,(TEM) ;GET THE BOTTOM ADDRESS - 1
POP P,BLOCK ;GET ADDRESS OF TOP OF BIG BLOCK
LDB TAC1,FSSBYP ;GET SIZE OF ORIGINAL
ADD TEM,TAC1 ;SUM THEM
DPB TEM,FSSBYP ;STUFF THEM IN THE ORIGINAL
HRROM BLOCK,1(DAT) ;SAVE A BOUNDARY MARKER.
JRST FSGV1
FSGV0: POP P,BLOCK ;GET THE TOP OF THIS BLOCK BACK.
FSGV1: MOVEI TAC,(BLOCK) ;GET ADDRESS OF GUY ABOVE
ADDI TAC,1 ; (SINCE MOVEI MIGHT OVERFLOW)
LSH TAC,-=9
PUSHJ P,CORGB1 ;GET A BYTE POINTER INTO TAC
LDB TAC,TAC ;GET CORTAB BYTE
CAIE TAC,105 ;SKIP IF NEXT HIGHER ADDRESS IS IN FS.
JRST FSGV2A ;ABOVE THIS BLOCK IS NOT MORE FS.
HRRZ TAC1,1(BLOCK) ;GET BOTTOM POINTER OF GUY ABOVE
CONI PI,DAT
ANDI DAT,PICMSK
CONO PI,PICHOF(DAT) ;STOP CHANNELS 3-7
HRRZ AC2,1(BLOCK) ;GET THE BOTTOM POINTER
SKIPG TAC,(AC2) ;GET THE FLINK
JRST FSGV2 ;ALL A BAD IDEA.
MOVE TAC1,-1(AC2) ;GET THE BLINK
HRRM TAC1,-1(TAC) ;GO FORWARD AND STUFF BLINK
HRRM TAC,(TAC1) ;GO BACK AND SET FLINK
CONO PI,PICHON(DAT) ;ALLOW INTERRUPTS AGAIN
MOVSI DAT,400000
IORM DAT,(AC2) ;CLAIM THIS BLOCK.
LDB TAC,FSSBP1 ;GET THE SIZE OF THIS GUY
LDB SIZE,FSSBYP
ADD SIZE,TAC
MOVE DAT,AC2
SUB DAT,SIZE ;COMPUTE THE BOTTOM ADDRESS
DPB SIZE,FSSBP1
HRROM AC2,1(DAT)
SKIPA BLOCK,AC2
FSGV2: CONO PI,PICHON(DAT)
FSGV2A: LDB SIZE,FSSBYP
LSH SIZE,1-TSHF ;SHIFT SIZE TO MAKE INDEX.
SUBI SIZE,2 ;FIX INDEX.
CAIL SIZE,NFSB*2 ;REASONABLE INDEX?
MOVEI SIZE,NFSB*2-2 ;NO. FIX INDEX.
JRST FSGV6
FSGV5: CONO PI,PICHON(TAC1) ;MAKE SURE PI'S GET RESTORED
FSGV6: MOVEI TAC,FSAVB+1(SIZE) ;GET THE LIST BASE
FSGV7: SKIPG DAT,(TAC) ;DOES THIS POINT FREE?
JRST FSGV6 ;NO TRY THIS LIST ALL OVER AGAIN
HRRZ TEM,(TAC) ;GET THE FLINK
CAIGE TEM,(BLOCK) ;HAVE WE FOUND THE RIGHT PLACE?
JRST FSGV8 ;YES. PREPARE TO LINK IT IN
CAME DAT,(TAC) ;IS THIS STILL THE SAME?
JRST FSGV6 ;NO. TRY ALL OVER
MOVEI TAC,(TEM) ;GET THE NEXT FLINK
JRST FSGV7 ;CHASE DOWN THIS LIST
FSGV8: HRRZM TAC,-1(BLOCK) ;SET THE BLINK
HRRM TEM,(BLOCK) ;SET THE FLINK
LDB AC2,FSSBYP ;GET THE SIZE OF BLOCK
SUBM BLOCK,AC2 ;GET POINTER TO BOTTOM
MOVSI SIZE,400000
ANDCAM SIZE,(BLOCK) ;TURN OFF CLAIM BIT
CONI PI,TAC1
ANDI TAC1,PICMSK
CONO PI,PICHOF(TAC1) ;HOLD CHANNELS 3-7
CAME DAT,(TAC) ;STILL HERE?
JRST FSGV5 ;WHAT A LOSS.
HRRM BLOCK,(TAC) ;STUFF IN NEW FLINK
HRRM BLOCK,-1(TEM) ;STUFF IN NEW BLINK
HRRZM BLOCK,1(AC2) ;AND TURN OFF BOTTOM MARK
CONO PI,PICHON(TAC1) ;ALLOW INTERRUPTS
HRRZ BLOCK,@MEMSIZ ;POINTER TO BOTTOM-MOST FS BLOCK
LDB SIZE,FSSBYP ;GET THE SIZE OF LOW BLOCK
SKIPL (BLOCK) ;SKIP IF BLOCK IS CLAIMED ALREADY
CAIGE SIZE,2000 ;UNCLAIMED. SKIP IF BIGGER THAN 1K
JRST FSXPOP ;CLAIMED OR NOT BIG ENOUGH
SKIPN FSCNT ;SKIP IF ANYONE'S WAITING
SETOM FSGVKF ;SET FLAG TO LET CLOCK THINK ABOUT IT
SETOM FSNCLK ;MAKE CLKSER CALL FSCLK
FSXPOP: PUSH P,J ;SAVE J, CLOBBERED BY FSWAKE
SKIPN PID ;P2 CAN'T WAKE ANYONE.
PUSHJ P,FSWAKE ;WAKE SOMEONE WHO WAITS.
POP P,J ;RESTORE J
FSPOP: POP P,BLOCK
XSYNC FSCSC
POPJ P,
FSQUIK: PUSHJ P,FSECHK ;CHECK ADDRESSES
FSQUK1: PUSH P,BLOCK
PUSH P,TEM
HRRZ BLOCK,-1(BLOCK) ;LOAD TOP ADDRESS FROM BOTTOM
PSYNC FSCSC
CONO PI,PIOFF ;ADD THIS BLOCK TO THE FREE LIST
HRRZ TEM,FSRTL ;GET THE FLINK
HRRM TEM,(BLOCK) ;SAVE HERE
HRRZM BLOCK,FSRTL ;RESET LIST BASE
CONO PI,PION ;DONE
SETOM FSNCLK
POP P,TEM
JRST FSPOP
;GET FREE STORAGE AT UUO LEVEL.
HISYS
↑UFSGET:
PUSHJ P,FSGET ;GET FREE STORAGE AT UUO LEVEL
JRST .+2 ;FAILURE CANNOT HAPPEN (IT SAYS HERE)
POPJ P, ;EXPECTED RETURN
PUSHACS ;STUFF EVERYTHING AWAY
PUSHJ P,DISDATE
PUSHJ P,DISMES
ASCIZ /NO FS AT UFSGET. /
CONSO PI,77400 ;ARE THERE ANY CHANNELS ACTIVE?
JRST UFSGT1 ;NO.
PUSHJ P,DISMES
ASCIZ /NOT AT UUO LEVEL! RETURN PC = /
MOVE TAC,P-17(P)
PUSHJ P,DISOCT
PUSHJ P,DISMES
ASCIZ / PI = /
CONI PI,TAC
PUSHJ P,DISLOC
UFSGT1: PUSHJ P,DISCRLF
POPACS
JSP DAT,UERROR ;GIVE A UUO ERROR.
;RELPDL - RELEASE THE JBTPDL
;CALL: MOVE J,<JOB NUMBER>
; PUSHJ P,RELPDL
COMMENT $
The free storage block that this PDL uses will be placed on the free
storage return list. The block will actually be returned the next
time that channel 7 is activated by the clock. The caller of RELPDL
must finish using the PDL at UUO level or clock level, whichever
level RELPDL is called from.
$
↑RELPDL:HRRZ BLOCK,JBTPDL(J) ;GET THE ADDRESS OF THE PDL
JUMPE BLOCK,CPOPJ ;NO PDL, CAN'T RELEASE
HRRZ TAC,JBTPDL(J) ;GET THE PDL ADDRESS
ADDI TAC,JBTPLN+JOBPRT-JOBPFI ;ADDRESS OF THE TOP IN TAC
SKIPN (TAC) ;LOOK FOR A NON-ZERO CELL
SOJGE TAC,.-1 ;LOOP.
SUB TAC,BLOCK ;SUBTRACT THE BASE ADDRESS.
CAMLE TAC,NPUSHD ;BIGGER THAN OUR BIGGEST
MOVEM TAC,NPUSHD ;YES. SAVE THIS NUMBER
SETZM JBTPDL(J) ;CLEAR PDL CELL FOR NEXT JOB
AOS NFSGIVES ;COUNT THIS CELL HERE, SINCE FAKING IT
MOVNI TAC,JBTPLN+2 ;GET THE SIZE OF THIS BLOCK
ADDM TAC,FSBUSY ;DECREASE BUSY COUNT TOO.
AOJA BLOCK,FSQUIK ;CHECK BLOCK, STUFF ON FSRTL, RETURN
;SPARE LIST HANDLER FOR DPYSER & TTYSER -- SFSINI SFSCLK
;HERE WE SET UP THE INITIAL QUOTAS (QUOTAE?)
SFSINI: HRRZ DDB,SFHEAD ;THE SPARE LIST LIST
SFSIOL: LDB DAT,[331000,,SFSIZE(DDB)] ;HOW MANY DOES THIS ONE WANT?
JUMPE DAT,SFSI2 ;NONE?
HRRZ AC3,SFSIZE(DDB)
MOVEI AC2,(DDB) ;INIT PNTR FOR LINKING
SFSIIL: PUSHJ P,FSGETU
JRST .+4 ;LOSE - SET TO TRY LATER (SHOULDN'T HAPPEN)
MOVEM AC1,(AC2) ;LINK IT IN
MOVEI AC2,(AC1)
SOJG DAT,SFSIIL
SETZM (AC2) ;TERMINATE LIST
MOVEM DAT,SPFSN(DDB) ;SET FROM DAT IN CASE WE LOST
SKIPL SFSIZE(DDB)
ADDM DAT,SPFSNT
SFSI2: HRRZ DDB,SFLINK(DDB)
JUMPN DDB,SFSIOL
POPJ P,
;WE GET HERE AT CLOCK LEVEL WHEN SPFSNT>0 TO REPLENISH OUR SPARES
↑SFSCLK:HRRZ DDB,SFHEAD
SFSCL1: SKIPLE SPFSN(DDB) ;IF THIS LIST DOESN'T NEED ANY
SKIPGE SFSIZE(DDB) ;OR THIS ISN'T THE CLOCK-FILLED KIND
JRST SFSCL2 ;TRY NEXT LIST
SFSCLL: HRRZ AC3,SFSIZE(DDB)
PUSHJ P,FSGET ;TRY TO GET ONE
JRST SFSCL2 ;LOSE - DON'T BOTHER WITH THIS LIST ANY MORE
CONO PI,PIOFF
EXCH AC1,(DDB) ;PUT IT IN THE LIST
MOVEM AC1,@(DDB)
CONO PI,PION
SOS AC1,SPFSNT ;DECREMENT TOTAL
SOSLE SPFSN(DDB) ;& # THIS LIST
JRST SFSCLL ;STILL NEED MORE
JUMPLE AC1,CPOPJ ;THIS LIST ALL SET, ANY OTHERS TO DO?
SFSCL2: HRRZ DDB,SFLINK(DDB) ;YES, TRY NEXT LIST
JUMPN DDB,SFSCL1 ;IF THERE IS ONE
POPJ P,
;VERSION OF FSGET TO USE SPARE LIST -- SFSGET
;LIKE FSGET EXCEPT AC3 HAS SPARE LIST HEADER POINTER INSTEAD OF SIZE
;SIGN BIT (AC3) MEANS NO SKIP (OR FAILURE) RETURN
;SFNWT BIT FORCES FAILURE RETURN EVEN AT UUO LEVEL
↑SFSGET:PUSH P,AC3
SKIPGE SFSIZE(AC3)
JRST SFGSF ;WANTS TO TRY SPARES FIRST
SFGFS: HRRZ AC3,SFSIZE(AC3)
PUSHJ P,FSGETU
JRST SFSGTS ;NO FS, TRY SPARE
SFSXIT: POP P,AC3
SFSWIN: JUMPGE AC3,CPOPJ1 ;HERE WE HAVE WON, AND GIVE THE REQUESTED SUCCESS RETURN
POPJ P,
SFSGTS: PUSHJ P,SFGTS ;TRY TO GET A SPARE
JRST SFSLUZ ;OOPS - NO SPARE, EITHER
SFSGOK: POP P,AC3
AOS SPFSN(AC3) ;NOW WE NEED ANOTHER
SKIPL SFSIZE(AC3) ;AND UNLESS WE'RE KEEPING SFSCLK OUT
AOS SPFSNT ;WE SHOULD REQUEST SERVICE FROM IT
JRST SFSWIN
SFGSF: PUSHJ P,SFGTS ;HERE WE TRY THE SPARES FIRST
SKIPA AC3,(P) ;LOSE - GET THE PNTR SO WE CAN GET THE SIZE FOR FSGET
JRST SFSGOK ;WIN - UPDATE THINGS & EXIT
JRST SFGFS ;NOW TRY FSGET
SFGTS: MOVEI AC3, ;PREPARE TO FLUSH LINK
CONO PI,PIOFF ;GET SPARE FROM LIST AT @(P)
SKIPN AC1,@-1(P)
JRST PIONJ ;NONE
EXCH AC3,(AC1) ;THIS ZEROES LINK TO TELL RELEX SOMETHING CHANGED
MOVEM AC3,@-1(P) ;DELINK IT FROM THE LIST
CONO PI,PION
JRST CPOPJ1
SFSLUZ: POP P,AC3
AOS SFLOSS(AC3) ;COUNT OUR TOTAL LOSSES
CONSO PI,77400
JRST SFULUZ ;UUO LEVEL - NOT TOO BAD
JUMPL AC3,SFILUZ ;IF WE CAN'T GIVE A FAILURE RETURN WE ARE IN DEEP TROUBLE
POPJ P, ;WHEW!
SFULUZ: TLNE AC3,SFNWT ;IF THE CALLER DOESN'T WANT TO WAIT
JUMPGE AC3,CPOPJ ;AND HE ALLOWS FAILURE, JUST RETURN
PUSH P,AC3
HRRZ AC3,SFSIZE(AC3)
PUSHJ P,UFSGET ;OTHERWISE OFF TO FSGET TO WAIT FOR IT
JRST SFSXIT
;ARRRGH! PI LEVEL AND NO FAILURE POSSIBLE! HERE WE CURL UP AND DIE
SFILUZ: HLRZ AC2,SFLOSS(AC3) ;MAYBE THE CONDEMNED HAS A FEW LAST WORDS
SKIPN AC2
MOVEI AC2,[ASCIZ /SOMETHING/] ;NOPE
PUSHACS
PUSHJ P,DISDAT
PUSHJ P,DISERR
[ASCIZ /πππππππNO CORE FOR /]
@AC2-20(P)
[ASCIZ / AT SFSGET.
/]
-1
PUSHJ P,DISFLUSH
PUSHJ P,DDTCALL ;MAYBE SOMEONE WANTS TO KNOW WHY
JRST AUTOLOAD ;AS THE SYSTEM SINKS SLOWLY INTO THE WEST
;VERSION OF FSGIVE TO THINK ABOUT PUTTING RETURNED BLOCK INTO SPARE LIST -- SFSGIV SFSREL
;LIKE FSGIVE BUT CALL IS FOLLOWED BY LIST HEADER ADDRESS
↑SFSGIV:PUSH P,AC3
AOS AC3,-1(P) ;SKIP OVER ARG
MOVEI AC3,@-1(AC3) ;& GET IT
SKIPGE SFSIZE(AC3) ;ONLY RETURN INTO LIST IF THIS BIT IS ON
SKIPG SPFSN(AC3) ;AND WE NEED SOME
JRST [POP P,AC3↔JRST FSGIVE] ;OTHERWISE GIVE IT BACK TO FS
PUSH P,AC1
ANDI AC1,-1
CONO PI,PIOFF
EXCH AC1,(AC3) ;LINK IT IN
MOVEM AC1,@(AC3)
CONO PI,PION
POP P,AC1
SOS SPFSN(AC3) ;ONE FEWER NEEDED
POP P,AC3
POPJ P,
;ROUTINE TO DYNAMICALLY SHRINK SIZE OF SPARE LIST
;CALL WITH -# TO DECREASE IN AC2, HEADER POINTER IN AC3 (CLOBBERS AC1 & AC2)
↑SFSREL:SKIPL SFSIZE(AC3) ;AS USUAL, THIS TYPE LEAVES SPFSNT ALONE
ADDM AC2,SPFSNT
ADDB AC2,SPFSN(AC3)
JUMPGE AC2,CPOPJ ;LEAVE IF WE DON'T HAVE TO GIVE ANY AWAY
SFSRLL: CONO PI,PIOFF
SKIPN AC1,(AC3) ;GET ONE
JRST PIONJ ;NONE
HRRZ AC2,(AC1)
MOVEM AC2,(AC3) ;LINK IT OUT
CONO PI,PION
PUSHJ P,FSGIVE ;AND GIVE IT BACK TO THE WORLD
SKIPL SFSIZE(AC3) ;THE UBIQUITOUS TEST (SIGH)
AOS SPFSNT
AOSGE SPFSN(AC3) ;ONE MORE "NEEDED" (SHOULD BE GOING UP TO 0)
JRST SFSRLL ;AND WE'LL KEEP AT IT UNTIL IT DOES
POPJ P,
;YES FANS, IT'S THE INFAMOUS RELEX, FORMERLY SCATTERED THROUGH TTYSER & DPYSER
;THIS ONE TRIES TO SHUFFLE UP ALL THE SPARES IN THE BOTTOM 1K
;BY REPLACING THEM WITH NEW ONES FROM FREE STORAGE
;IT GIVES UP QUICKLY IF THE NEW ONES AREN'T ABOVE THE BOTTOM 1K
RELEX: MOVE AC2,MEMSIZ
ADDI AC2,2000 ;THIS WILL BE OUR THRESHOLD
CAML AC2,RMEMSIZ ;BUT LEAVE THE TOP 1K ALONE
POPJ P, ;IF THIS INSTRUCTION GETS EXECUTED SOMEONE DESERVES OUR WARMEST CONGRATULATIONS
HLRZ DDB,SFHEAD ;THERE WAS ONCE A REASON FOR GOING THROUGH BACKWARDS
RELX1: MOVEI TAC,(DDB) ;START THE "PREVIOUS" POINTER HERE
RELX2: HRRZ TEM,(TAC) ;CONSIDER A BLOCK
JUMPE TEM,RELXO ;GEE, WASN'T THAT EASY
CAIL TEM,(AC2)
JRST RELXI ;HE'S NOT IN THE BOTTOM 1K, SO WE WON'T WORRY ABOUT HIM NOW
MOVE TAC1,(TEM) ;PICK UP HIS LINK
HRRZ AC3,SFSIZE(DDB) ;HE MUST BE THIS BIG
PUSHJ P,FSGET ;GET A SHINY NEW PIECE
JRST RELXO ;OH WELL, SO MUCH FOR THIS LIST
CAIGE AC1,(AC2) ;SEE IF THE NEW ONE IS ABOVE THE BOTTOM 1K
JRST RELXL ;TIME TO SEE THE COMPLAINT DEPARTMENT
MOVEM TAC1,(AC1) ;COPY THE LINK
CONO PI,PIOFF ;NOW CLOSE OUR EYES
CAMN TAC1,(TEM) ;AND IF THESE 2 POINTERS
CAME TEM,(TAC) ;STILL AGREE
JRST [CONO PI,PION↔JRST RELXL] ;CURSES! FOILED AGAIN! GIVE BACK NEW BLOCK.
MOVEM AC1,(TAC) ;QUICK! PULL THE SWITCH!
CONO PI,PION ;DIDN'T SEE A THING
EXCH AC1,TEM ;DON'T FORGET TO TELL FSGIVE ABOUT THE SWITCH
PUSHJ P,FSGIVE ;NOW GET RID OF THE LOSER
RELXI: MOVE TAC,TEM ;THIS IS NOW THE PREVIOUS BLOCK
JRST RELX2
RELXL: PUSHJ P,FSGIVE ;GIVE BACK THE NEW ONE
RELXO: HLRZ DDB,SFLINK(DDB) ;AND TRY A NEW LIST
JUMPN DDB,RELX1 ;IF THERE'S ONE TO BE FOUND
POPJ P,
;GETMAP,GIVMAP MANIPULATE 512-WORD PAGES OF FREE STORAGE.
;RETURNS IN BLOCK THE ADDRESS OF A 512-WORD PAGE MAP, CONTAINING ALL ZEROS.
;SKIPS ON SUCCESS. CALL AT UUO-LEVEL OR FROM CHANNEL-7 ONLY!
↑GETMAP:PUSHJ P,FSACSV ;SAVE SOME ACS
PUSHJ P,FSGETP ;SPECIAL FS CALL. RETURNS A PAGE
JRST GETMP3 ;LOSE. RESTORE ACS AND DIRECT-RETURN
MOVEI TAC,(BLOCK) ;MAKE INTO NEW FORMAT FS BLOCK.
LSH TAC,-=9
PUSHJ P,CORGB1 ;MAKE CORTAB BYTE POINTER.
MOVEI AC2,110 ;CODE - MAP PAGE - BUSY
DPB AC2,TAC ;CHANGE CORTAB ENTRY.
SUBI BLOCK,1 ;POINTS TO THE PAGE
MOVSI AC2,(BLOCK)
HRRI AC2,1(BLOCK)
SETZM (BLOCK)
BLT AC2,777(BLOCK)
JSP DAT,FSACRS ;SKIP RETURN, RESTORING ACS
LSH BLOCK,-=9 ;RETURN PAGE NUMBER OF THIS PAGE.
JRST CPOPJ1
;RETURN A 512-WORD PAGE TO FREE STORAGE. CALL WITH ADDRESS IN BLOCK.
↑GIVMAP:PUSHJ P,FSACSV ;SAVE SOME ACS
LSH BLOCK,=9 ;CONVERT TO A WORD ADDRESS
MOVEI TAC1,777(BLOCK) ;HIGH ADDRESS.
MOVSI AC2,401000 ;SIZE FIELD FOR FS BLOCK.
MOVEM AC2,(TAC1) ;STUFF IN HIGH WORD
HRROM TAC1,(BLOCK) ;STUFF UP POINTER IN LOW WORD
LDB TAC,[POINT 9,BLOCK,26]
PUSHJ P,CORGB1
MOVEI TAC1,105 ;SET CORTAB CODE TO FREE STORAGE.
DPB TAC1,TAC
ADDI BLOCK,1 ;MAKE BLOCK POINT TO NORMAL STYLE FS BLOCK
PUSHJ P,FSGIVE ;GIVE IT AWAY
GETMP3: JSP DAT,FSACRS
POPJ P,
BEND CORE
↑HIDVBG←←0
IFN FTHSYS,<↑HIDVBG←←.> ;FTHSYS
LOSYS
↑DEVBEG←←. ;START OF THE DEV SERVICES IN ENTIRE SYSTEM
HISYS